@theia/ai-ide 1.77.0-next.99 → 1.78.0-next.0

package/lib/browser/ai-configuration/categories/agent-capabilities-settings.spec.js

@@ -1,4 +1,3 @@
-"use strict";
 // *****************************************************************************
 // Copyright (C) 2026 EclipseSource and others.
 //
@@ -14,24 +13,20 @@
 //
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const jsdom_1 = require("@theia/core/lib/browser/test/jsdom");
-let disableJSDOM = (0, jsdom_1.enableJSDOM)();
-const frontend_application_config_provider_1 = require("@theia/core/lib/browser/frontend-application-config-provider");
-frontend_application_config_provider_1.FrontendApplicationConfigProvider.set({});
-const chai_1 = require("chai");
-const sinon = tslib_1.__importStar(require("sinon"));
-const preference_provider_1 = require("@theia/core/lib/common/preferences/preference-provider");
-const promise_util_1 = require("@theia/core/lib/common/promise-util");
-const React = tslib_1.__importStar(require("@theia/core/shared/react"));
-const react_dom_1 = require("@theia/core/shared/react-dom");
-const client_1 = require("@theia/core/shared/react-dom/client");
-const GenericCapabilitiesTreeModule = tslib_1.__importStar(require("@theia/ai-chat-ui/lib/browser/generic-capabilities-tree"));
-const agent_capabilities_settings_1 = require("./agent-capabilities-settings");
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+let disableJSDOM = enableJSDOM();
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+FrontendApplicationConfigProvider.set({});
+import { expect } from 'chai';
+import { PreferenceUtils } from '@theia/core/lib/common/preferences/preference-provider';
+import { Deferred } from '@theia/core/lib/common/promise-util';
+import * as React from '@theia/core/shared/react';
+import { flushSync } from '@theia/core/shared/react-dom';
+import { createRoot } from '@theia/core/shared/react-dom/client';
+import { AgentGenericCapabilitiesSettings, AgentServerToolsSettings } from './agent-capabilities-settings.js';
 disableJSDOM();
 describe('AgentServerToolsSettings', () => {
-    before(() => disableJSDOM = (0, jsdom_1.enableJSDOM)());
+    before(() => disableJSDOM = enableJSDOM());
     after(() => disableJSDOM());
     const tools = [
         { id: 'web_search', name: 'Web Search', description: 'Search the web' },
@@ -48,8 +43,8 @@ describe('AgentServerToolsSettings', () => {
         };
         const container = document.createElement('div');
         document.body.appendChild(container);
-        const root = (0, client_1.createRoot)(container);
-        (0, react_dom_1.flushSync)(() => root.render(React.createElement(agent_capabilities_settings_1.AgentServerToolsSettings, {
+        const root = createRoot(container);
+        flushSync(() => root.render(React.createElement(AgentServerToolsSettings, {
             agentId: 'coder',
             tools,
             vendor: 'anthropic',
@@ -57,15 +52,15 @@ describe('AgentServerToolsSettings', () => {
             aiSettingsService,
             settingsRowService
         })));
-        return { container, updates, resets, dispose: () => { (0, react_dom_1.flushSync)(() => root.unmount()); container.remove(); } };
+        return { container, updates, resets, dispose: () => { flushSync(() => root.unmount()); container.remove(); } };
     }
     it('lists one toggle per tool the model offers, checked for the enabled ones', () => {
         const { container, dispose } = render({ anthropic: ['web_search'] });
         try {
             const checkboxes = Array.from(container.querySelectorAll('input[type=checkbox]'));
-            (0, chai_1.expect)(checkboxes.map(checkbox => checkbox.checked)).to.deep.equal([true, false]);
-            (0, chai_1.expect)(container.textContent).to.include('Web Search');
-            (0, chai_1.expect)(container.textContent).to.include('Search the web');
+            expect(checkboxes.map(checkbox => checkbox.checked)).to.deep.equal([true, false]);
+            expect(container.textContent).to.include('Web Search');
+            expect(container.textContent).to.include('Search the web');
         }
         finally {
             dispose();
@@ -75,7 +70,7 @@ describe('AgentServerToolsSettings', () => {
         const { container, dispose } = render({ anthropic: ['web_search'] });
         try {
             const rows = Array.from(container.querySelectorAll('.ai-configuration-item-row'));
-            (0, chai_1.expect)(rows.map(row => row.classList.contains('modified'))).to.deep.equal([true, false]);
+            expect(rows.map(row => row.classList.contains('modified'))).to.deep.equal([true, false]);
         }
         finally {
             dispose();
@@ -84,9 +79,9 @@ describe('AgentServerToolsSettings', () => {
     it('stores the enabled ids under the model vendor when a tool is switched on', async () => {
         const { container, updates, dispose } = render();
         try {
-            (0, react_dom_1.flushSync)(() => container.querySelectorAll('input[type=checkbox]')[0].click());
+            flushSync(() => container.querySelectorAll('input[type=checkbox]')[0].click());
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(updates).to.deep.equal([{ serverToolSelections: { anthropic: ['web_search'] } }]);
+            expect(updates).to.deep.equal([{ serverToolSelections: { anthropic: ['web_search'] } }]);
         }
         finally {
             dispose();
@@ -95,10 +90,10 @@ describe('AgentServerToolsSettings', () => {
     it('drops the vendor entry instead of storing an empty list when the last tool is switched off', async () => {
         const { container, updates, dispose } = render({ anthropic: ['web_search'] });
         try {
-            (0, react_dom_1.flushSync)(() => container.querySelectorAll('input[type=checkbox]')[0].click());
+            flushSync(() => container.querySelectorAll('input[type=checkbox]')[0].click());
             await new Promise(resolve => setTimeout(resolve, 0));
             // The whole setting goes when no vendor has a selection left, so no stale keys accumulate.
-            (0, chai_1.expect)(updates).to.deep.equal([{ serverToolSelections: undefined }]);
+            expect(updates).to.deep.equal([{ serverToolSelections: undefined }]);
         }
         finally {
             dispose();
@@ -107,7 +102,7 @@ describe('AgentServerToolsSettings', () => {
     it('offers a reset on the section header only while something is enabled, and leaves other vendors alone', async () => {
         const nothingEnabled = render();
         try {
-            (0, chai_1.expect)(Boolean(nothingEnabled.container.querySelector('.ai-agent-section-header-action'))).to.equal(false);
+            expect(Boolean(nothingEnabled.container.querySelector('.ai-agent-section-header-action'))).to.equal(false);
         }
         finally {
             nothingEnabled.dispose();
@@ -116,9 +111,9 @@ describe('AgentServerToolsSettings', () => {
         try {
             // On the header line, not in a row of its own above the list.
             const reset = container.querySelector('.ai-agent-section-header .ai-agent-section-header-action');
-            (0, react_dom_1.flushSync)(() => reset.click());
+            flushSync(() => reset.click());
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(updates).to.deep.equal([{ serverToolSelections: { openai: ['code_execution'] } }]);
+            expect(updates).to.deep.equal([{ serverToolSelections: { openai: ['code_execution'] } }]);
         }
         finally {
             dispose();
@@ -129,13 +124,13 @@ describe('AgentServerToolsSettings', () => {
         try {
             const gears = Array.from(container.querySelectorAll('.ai-configuration-item-row-actions'));
             // Only the enabled row deviates from the default, so only it offers a reset.
-            (0, chai_1.expect)(gears).to.have.lengthOf(1);
+            expect(gears).to.have.lengthOf(1);
             const gear = container.querySelector('.ai-settings-row-gear');
-            (0, react_dom_1.flushSync)(() => gear.click());
-            (0, chai_1.expect)(resets).to.have.lengthOf(1);
+            flushSync(() => gear.click());
+            expect(resets).to.have.lengthOf(1);
             resets[0]();
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(updates).to.deep.equal([{ serverToolSelections: undefined }]);
+            expect(updates).to.deep.equal([{ serverToolSelections: undefined }]);
         }
         finally {
             dispose();
@@ -144,9 +139,9 @@ describe('AgentServerToolsSettings', () => {
 });
 describe('AgentGenericCapabilitiesSettings', () => {
     before(() => {
-        disableJSDOM = (0, jsdom_1.enableJSDOM)();
+        disableJSDOM = enableJSDOM();
         // The tree's root tooltips read the application name; the config lives on the fresh window.
-        frontend_application_config_provider_1.FrontendApplicationConfigProvider.set({});
+        FrontendApplicationConfigProvider.set({});
     });
     after(() => disableJSDOM());
     const available = {
@@ -157,14 +152,14 @@ describe('AgentGenericCapabilitiesSettings', () => {
         agentDelegation: [],
         variables: []
     };
-    function render(savedSelections, availableCapabilities, deferWrites = false) {
+    function render(savedSelections, availableCapabilities, deferWrites = false, capabilitiesTree) {
         const updates = [];
         let stored = savedSelections;
         const writes = [];
         const reads = [];
         const aiSettingsService = {
             getAgentSettings: async (agentId) => {
-                (0, chai_1.expect)(agentId).to.equal('coder');
+                expect(agentId).to.equal('coder');
                 const deferred = reads.shift();
                 return { genericCapabilitySelections: deferred ? await deferred.promise : stored };
             },
@@ -172,7 +167,7 @@ describe('AgentGenericCapabilitiesSettings', () => {
                 updates.push(settings);
                 const next = settings.genericCapabilitySelections;
                 // PreferenceServiceImpl skips a write if it equals the value currently stored, not a pending value.
-                if (preference_provider_1.PreferenceUtils.deepEqual(stored, next)) {
+                if (PreferenceUtils.deepEqual(stored, next)) {
                     return;
                 }
                 if (deferWrites) {
@@ -196,8 +191,8 @@ describe('AgentGenericCapabilitiesSettings', () => {
         };
         const container = document.createElement('div');
         document.body.appendChild(container);
-        const root = (0, client_1.createRoot)(container);
-        const reload = (saved) => (0, react_dom_1.flushSync)(() => root.render(React.createElement(agent_capabilities_settings_1.AgentGenericCapabilitiesSettings, {
+        const root = createRoot(container);
+        const reload = (saved) => flushSync(() => root.render(React.createElement(AgentGenericCapabilitiesSettings, {
             agentId: 'coder',
             savedSelections: saved,
             availableCapabilities,
@@ -205,7 +200,8 @@ describe('AgentGenericCapabilitiesSettings', () => {
             aiSettingsService,
             settingsRowService: { openResetMenu: () => { } },
             hoverService: { requestHover: () => { } },
-            onOpenPromptSnippet: () => { }
+            onOpenPromptSnippet: () => { },
+            capabilitiesTree
         })));
         reload(savedSelections);
         return {
@@ -221,18 +217,18 @@ describe('AgentGenericCapabilitiesSettings', () => {
                 writes[index](error);
             },
             deferRead: () => {
-                const deferred = new promise_util_1.Deferred();
+                const deferred = new Deferred();
                 reads.push(deferred);
                 return deferred;
             },
-            dispose: () => { (0, react_dom_1.flushSync)(() => root.unmount()); container.remove(); }
+            dispose: () => { flushSync(() => root.unmount()); container.remove(); }
         };
     }
     function openEditorAndExpand(container, rootName) {
-        (0, react_dom_1.flushSync)(() => container.querySelector('button[aria-label="Edit generic capabilities"]').click());
+        flushSync(() => container.querySelector('button[aria-label="Edit generic capabilities"]').click());
         const header = Array.from(container.querySelectorAll('.theia-GenericCapabilities-TreeNodeHeader'))
             .find(candidate => candidate.textContent === rootName);
-        (0, react_dom_1.flushSync)(() => header.click());
+        flushSync(() => header.click());
     }
     function item(container, name) {
         return Array.from(container.querySelectorAll('.theia-GenericCapabilities-TreeItem')).find(candidate => candidate.textContent === name);
@@ -253,8 +249,8 @@ describe('AgentGenericCapabilitiesSettings', () => {
     it('offers no editor when there is nothing to choose from', () => {
         const { container, dispose } = render({ skills: ['skill-a'] }, undefined);
         try {
-            (0, chai_1.expect)(Boolean(container.querySelector('button[aria-label="Edit generic capabilities"]'))).to.equal(false);
-            (0, chai_1.expect)(container.textContent).to.include('skill-a');
+            expect(Boolean(container.querySelector('button[aria-label="Edit generic capabilities"]'))).to.equal(false);
+            expect(container.textContent).to.include('skill-a');
         }
         finally {
             dispose();
@@ -264,15 +260,15 @@ describe('AgentGenericCapabilitiesSettings', () => {
         const { container, updates, dispose } = render(undefined, available);
         try {
             openEditorAndExpand(container, 'Skills');
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-a').click());
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-b').click());
+            flushSync(() => item(container, 'skill-a').click());
+            flushSync(() => item(container, 'skill-b').click());
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(updates).to.deep.equal([
+            expect(updates).to.deep.equal([
                 { genericCapabilitySelections: { skills: ['skill-a'] } },
                 { genericCapabilitySelections: { skills: ['skill-a', 'skill-b'] } }
             ]);
             // The summary row reflects the edit without waiting for the saved value to be reloaded.
-            (0, chai_1.expect)(container.querySelector('.ai-configuration-item-list').textContent).to.include('skill-a, skill-b');
+            expect(container.querySelector('.ai-configuration-item-list').textContent).to.include('skill-a, skill-b');
         }
         finally {
             dispose();
@@ -282,15 +278,15 @@ describe('AgentGenericCapabilitiesSettings', () => {
         const { container, updates, reload, dispose } = render(undefined, available);
         try {
             openEditorAndExpand(container, 'Skills');
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-a').click());
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-b').click());
+            flushSync(() => item(container, 'skill-a').click());
+            flushSync(() => item(container, 'skill-b').click());
             await new Promise(resolve => setTimeout(resolve, 0));
             reload({ skills: ['skill-a'] });
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-a').click());
+            expect(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
+            flushSync(() => item(container, 'skill-a').click());
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(updates[2]).to.deep.equal({ genericCapabilitySelections: { skills: ['skill-b'] } });
+            expect(updates[2]).to.deep.equal({ genericCapabilitySelections: { skills: ['skill-b'] } });
         }
         finally {
             dispose();
@@ -300,17 +296,17 @@ describe('AgentGenericCapabilitiesSettings', () => {
         const { container, updates, reload, dispose } = render(undefined, available);
         try {
             openEditorAndExpand(container, 'Skills');
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-a').click());
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-b').click());
+            flushSync(() => item(container, 'skill-a').click());
+            flushSync(() => item(container, 'skill-b').click());
             await new Promise(resolve => setTimeout(resolve, 0));
             reload({ skills: ['skill-a', 'skill-b'] });
             await new Promise(resolve => setTimeout(resolve, 0));
             reload({ skills: ['skill-a'] });
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-a').click());
+            expect(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
+            flushSync(() => item(container, 'skill-a').click());
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(updates[2]).to.deep.equal({ genericCapabilitySelections: { skills: ['skill-b'] } });
+            expect(updates[2]).to.deep.equal({ genericCapabilitySelections: { skills: ['skill-b'] } });
         }
         finally {
             dispose();
@@ -320,15 +316,15 @@ describe('AgentGenericCapabilitiesSettings', () => {
         const { container, updates, reload, dispose } = render(undefined, available);
         try {
             openEditorAndExpand(container, 'Skills');
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-a').click());
-            (0, react_dom_1.flushSync)(() => container.querySelector('button[aria-label="Reset all generic capability selections"]').click());
+            flushSync(() => item(container, 'skill-a').click());
+            flushSync(() => container.querySelector('button[aria-label="Reset all generic capability selections"]').click());
             await new Promise(resolve => setTimeout(resolve, 0));
             reload({ skills: ['skill-a'] });
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(item(container, 'skill-a').querySelector('input').checked).to.equal(false);
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-b').click());
+            expect(item(container, 'skill-a').querySelector('input').checked).to.equal(false);
+            flushSync(() => item(container, 'skill-b').click());
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(updates[2]).to.deep.equal({ genericCapabilitySelections: { skills: ['skill-b'] } });
+            expect(updates[2]).to.deep.equal({ genericCapabilitySelections: { skills: ['skill-b'] } });
         }
         finally {
             dispose();
@@ -338,20 +334,20 @@ describe('AgentGenericCapabilitiesSettings', () => {
         const { container, updates, finishWrite, getStored, dispose } = render(undefined, available, true);
         try {
             openEditorAndExpand(container, 'Skills');
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-a').click());
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-b').click());
+            flushSync(() => item(container, 'skill-a').click());
+            flushSync(() => item(container, 'skill-b').click());
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(updates).to.have.lengthOf(1);
-            (0, chai_1.expect)(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
+            expect(updates).to.have.lengthOf(1);
+            expect(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
             await finishWrite(0);
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(updates).to.have.lengthOf(2);
-            (0, chai_1.expect)(getStored()).to.deep.equal({ skills: ['skill-a'] });
-            (0, chai_1.expect)(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
+            expect(updates).to.have.lengthOf(2);
+            expect(getStored()).to.deep.equal({ skills: ['skill-a'] });
+            expect(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
             await finishWrite(1);
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(getStored()).to.deep.equal({ skills: ['skill-a', 'skill-b'] });
-            (0, chai_1.expect)(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
+            expect(getStored()).to.deep.equal({ skills: ['skill-a', 'skill-b'] });
+            expect(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
         }
         finally {
             dispose();
@@ -361,21 +357,21 @@ describe('AgentGenericCapabilitiesSettings', () => {
         const { container, updates, finishWrite, getStored, dispose } = render({ skills: ['skill-a'] }, available, true);
         try {
             openEditorAndExpand(container, 'Skills');
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-b').click());
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-b').click());
-            (0, chai_1.expect)(item(container, 'skill-b').querySelector('input').checked).to.equal(false);
+            flushSync(() => item(container, 'skill-b').click());
+            flushSync(() => item(container, 'skill-b').click());
+            expect(item(container, 'skill-b').querySelector('input').checked).to.equal(false);
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(updates).to.have.lengthOf(1);
+            expect(updates).to.have.lengthOf(1);
             await finishWrite(0);
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(getStored()).to.deep.equal({ skills: ['skill-a', 'skill-b'] });
-            (0, chai_1.expect)(updates).to.have.lengthOf(2);
-            (0, chai_1.expect)(item(container, 'skill-b').querySelector('input').checked).to.equal(false);
+            expect(getStored()).to.deep.equal({ skills: ['skill-a', 'skill-b'] });
+            expect(updates).to.have.lengthOf(2);
+            expect(item(container, 'skill-b').querySelector('input').checked).to.equal(false);
             await finishWrite(1);
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(getStored()).to.deep.equal({ skills: ['skill-a'] });
-            (0, chai_1.expect)(item(container, 'skill-a').querySelector('input').checked).to.equal(true);
-            (0, chai_1.expect)(item(container, 'skill-b').querySelector('input').checked).to.equal(false);
+            expect(getStored()).to.deep.equal({ skills: ['skill-a'] });
+            expect(item(container, 'skill-a').querySelector('input').checked).to.equal(true);
+            expect(item(container, 'skill-b').querySelector('input').checked).to.equal(false);
         }
         finally {
             dispose();
@@ -383,47 +379,46 @@ describe('AgentGenericCapabilitiesSettings', () => {
     });
     it('preserves a rejected save promise without poisoning later queued writes', async () => {
         let change;
-        const tree = sinon.stub(GenericCapabilitiesTreeModule, 'GenericCapabilitiesTree').callsFake(props => {
+        const tree = (props) => {
             change = props.onGenericCapabilityChange;
             return React.createElement('div');
-        });
-        const { container, updates, rejectWrite, finishWrite, getStored, dispose } = render(undefined, available, true);
+        };
+        const { container, updates, rejectWrite, finishWrite, getStored, dispose } = render(undefined, available, true, tree);
         try {
-            (0, react_dom_1.flushSync)(() => container.querySelector('button[aria-label="Edit generic capabilities"]').click());
+            flushSync(() => container.querySelector('button[aria-label="Edit generic capabilities"]').click());
             let failed;
             let queued;
-            (0, react_dom_1.flushSync)(() => {
+            flushSync(() => {
                 failed = change('skills', ['skill-a']);
                 queued = change('skills', ['skill-a', 'skill-b']);
             });
             const failure = new Error('Write failed');
-            const rejection = failed.then(() => chai_1.expect.fail('Expected the save to reject'), error => (0, chai_1.expect)(error).to.equal(failure));
+            const rejection = failed.then(() => expect.fail('Expected the save to reject'), error => expect(error).to.equal(failure));
             const queuedResult = queued.then(() => undefined, error => error);
             await rejectWrite(0, failure);
             await rejection;
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(updates).to.have.lengthOf(2);
+            expect(updates).to.have.lengthOf(2);
             await finishWrite(1);
-            (0, chai_1.expect)(await queuedResult).to.equal(undefined);
-            (0, chai_1.expect)(getStored()).to.deep.equal({ skills: ['skill-a', 'skill-b'] });
+            expect(await queuedResult).to.equal(undefined);
+            expect(getStored()).to.deep.equal({ skills: ['skill-a', 'skill-b'] });
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(container.querySelector('.ai-configuration-item-list').textContent).to.include('skill-a, skill-b');
+            expect(container.querySelector('.ai-configuration-item-list').textContent).to.include('skill-a, skill-b');
         }
         finally {
             dispose();
-            tree.restore();
         }
     });
     it('rolls back a swallowed write failure after its change event and resolving promise', async () => {
         const { container, finishWrite, dispose } = render({ skills: ['skill-a'] }, available, true);
         try {
             openEditorAndExpand(container, 'Skills');
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-b').click());
-            (0, chai_1.expect)(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
+            flushSync(() => item(container, 'skill-b').click());
+            expect(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
             await finishWrite(0, false);
             await waitUntil(() => !isChecked(container, 'skill-b'));
-            (0, chai_1.expect)(item(container, 'skill-b').querySelector('input').checked).to.equal(false);
-            (0, chai_1.expect)(item(container, 'skill-a').querySelector('input').checked).to.equal(true);
+            expect(item(container, 'skill-b').querySelector('input').checked).to.equal(false);
+            expect(item(container, 'skill-a').querySelector('input').checked).to.equal(true);
         }
         finally {
             dispose();
@@ -433,18 +428,18 @@ describe('AgentGenericCapabilitiesSettings', () => {
         const { container, finishWrite, updates, dispose } = render(undefined, available, true);
         try {
             openEditorAndExpand(container, 'Skills');
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-a').click());
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-b').click());
+            flushSync(() => item(container, 'skill-a').click());
+            flushSync(() => item(container, 'skill-b').click());
             await finishWrite(0);
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
+            expect(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
             await finishWrite(1, false);
             await waitUntil(() => !isChecked(container, 'skill-b'));
-            (0, chai_1.expect)(item(container, 'skill-a').querySelector('input').checked).to.equal(true);
-            (0, chai_1.expect)(item(container, 'skill-b').querySelector('input').checked).to.equal(false);
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-a').click());
+            expect(item(container, 'skill-a').querySelector('input').checked).to.equal(true);
+            expect(item(container, 'skill-b').querySelector('input').checked).to.equal(false);
+            flushSync(() => item(container, 'skill-a').click());
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(updates[2]).to.deep.equal({ genericCapabilitySelections: undefined });
+            expect(updates[2]).to.deep.equal({ genericCapabilitySelections: undefined });
             await finishWrite(2);
         }
         finally {
@@ -455,21 +450,21 @@ describe('AgentGenericCapabilitiesSettings', () => {
         const { container, reload, setStored, dispose } = render({ skills: ['skill-a'] }, available);
         try {
             openEditorAndExpand(container, 'Skills');
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-b').click());
+            flushSync(() => item(container, 'skill-b').click());
             await new Promise(resolve => setTimeout(resolve, 0));
             setStored({ skills: ['skill-b'] });
             reload({ skills: ['skill-b'] });
             await waitUntil(() => !isChecked(container, 'skill-a'));
-            (0, chai_1.expect)(item(container, 'skill-a').querySelector('input').checked).to.equal(false);
+            expect(item(container, 'skill-a').querySelector('input').checked).to.equal(false);
             setStored({ skills: ['skill-a'] });
             reload({ skills: ['skill-a'] });
             await waitUntil(() => isChecked(container, 'skill-a') && !isChecked(container, 'skill-b'));
-            (0, chai_1.expect)(item(container, 'skill-a').querySelector('input').checked).to.equal(true);
-            (0, chai_1.expect)(item(container, 'skill-b').querySelector('input').checked).to.equal(false);
+            expect(item(container, 'skill-a').querySelector('input').checked).to.equal(true);
+            expect(item(container, 'skill-b').querySelector('input').checked).to.equal(false);
             setStored(undefined);
             reload(undefined);
             await waitUntil(() => !isChecked(container, 'skill-a'));
-            (0, chai_1.expect)(item(container, 'skill-a').querySelector('input').checked).to.equal(false);
+            expect(item(container, 'skill-a').querySelector('input').checked).to.equal(false);
         }
         finally {
             dispose();
@@ -479,12 +474,12 @@ describe('AgentGenericCapabilitiesSettings', () => {
         const { container, reload, setStored, dispose } = render(undefined, available);
         try {
             openEditorAndExpand(container, 'Skills');
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-a').click());
+            flushSync(() => item(container, 'skill-a').click());
             await new Promise(resolve => setTimeout(resolve, 0));
             setStored(undefined);
             reload(undefined);
             await waitUntil(() => !isChecked(container, 'skill-a'));
-            (0, chai_1.expect)(item(container, 'skill-a').querySelector('input').checked).to.equal(false);
+            expect(item(container, 'skill-a').querySelector('input').checked).to.equal(false);
         }
         finally {
             dispose();
@@ -494,18 +489,18 @@ describe('AgentGenericCapabilitiesSettings', () => {
         const { container, reload, setStored, finishWrite, dispose } = render(undefined, available, true);
         try {
             openEditorAndExpand(container, 'Skills');
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-a').click());
+            flushSync(() => item(container, 'skill-a').click());
             await finishWrite(0);
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-b').click());
+            flushSync(() => item(container, 'skill-b').click());
             setStored(undefined);
             reload({});
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
+            expect(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
             await finishWrite(1, false);
             await waitUntil(() => !isChecked(container, 'skill-a') && !isChecked(container, 'skill-b'));
-            (0, chai_1.expect)(item(container, 'skill-a').querySelector('input').checked).to.equal(false);
-            (0, chai_1.expect)(item(container, 'skill-b').querySelector('input').checked).to.equal(false);
+            expect(item(container, 'skill-a').querySelector('input').checked).to.equal(false);
+            expect(item(container, 'skill-b').querySelector('input').checked).to.equal(false);
         }
         finally {
             dispose();
@@ -518,14 +513,14 @@ describe('AgentGenericCapabilitiesSettings', () => {
             await new Promise(resolve => setTimeout(resolve, 0));
             const staleRead = deferRead();
             reload({ skills: ['skill-a'] });
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-b').click());
+            flushSync(() => item(container, 'skill-b').click());
             await new Promise(resolve => setTimeout(resolve, 0));
             staleRead.resolve({ skills: ['skill-a'] });
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-a').click());
+            expect(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
+            flushSync(() => item(container, 'skill-a').click());
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(updates[1]).to.deep.equal({ genericCapabilitySelections: { skills: ['skill-b'] } });
+            expect(updates[1]).to.deep.equal({ genericCapabilitySelections: { skills: ['skill-b'] } });
         }
         finally {
             dispose();
@@ -535,17 +530,17 @@ describe('AgentGenericCapabilitiesSettings', () => {
         const { container, finishWrite, deferRead, dispose } = render(undefined, available, true);
         try {
             openEditorAndExpand(container, 'Skills');
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-a').click());
+            flushSync(() => item(container, 'skill-a').click());
             const staleRead = deferRead();
             await finishWrite(0);
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-b').click());
+            flushSync(() => item(container, 'skill-b').click());
             staleRead.resolve({ skills: ['skill-a'] });
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
+            expect(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
             await finishWrite(1);
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
+            expect(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
         }
         finally {
             dispose();
@@ -563,8 +558,8 @@ describe('AgentGenericCapabilitiesSettings', () => {
             await new Promise(resolve => setTimeout(resolve, 0));
             staleRead.resolve({ skills: ['skill-a'] });
             await waitUntil(() => isChecked(container, 'skill-b'));
-            (0, chai_1.expect)(item(container, 'skill-a').querySelector('input').checked).to.equal(false);
-            (0, chai_1.expect)(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
+            expect(item(container, 'skill-a').querySelector('input').checked).to.equal(false);
+            expect(item(container, 'skill-b').querySelector('input').checked).to.equal(true);
         }
         finally {
             dispose();
@@ -576,13 +571,13 @@ describe('AgentGenericCapabilitiesSettings', () => {
             openEditorAndExpand(container, 'Skills');
             const functions = Array.from(container.querySelectorAll('.theia-GenericCapabilities-TreeNodeHeader'))
                 .find(candidate => candidate.textContent === 'Functions');
-            (0, react_dom_1.flushSync)(() => functions.click());
-            (0, react_dom_1.flushSync)(() => {
+            flushSync(() => functions.click());
+            flushSync(() => {
                 item(container, 'skill-a').click();
                 item(container, 'fn-a').click();
             });
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(updates[1]).to.deep.equal({ genericCapabilitySelections: { skills: ['skill-a'], functions: ['fn-a'] } });
+            expect(updates[1]).to.deep.equal({ genericCapabilitySelections: { skills: ['skill-a'], functions: ['fn-a'] } });
         }
         finally {
             dispose();
@@ -592,9 +587,9 @@ describe('AgentGenericCapabilitiesSettings', () => {
         const { container, updates, dispose } = render({ skills: ['skill-a'] }, available);
         try {
             openEditorAndExpand(container, 'Skills');
-            (0, react_dom_1.flushSync)(() => item(container, 'skill-a').click());
+            flushSync(() => item(container, 'skill-a').click());
             await new Promise(resolve => setTimeout(resolve, 0));
-            (0, chai_1.expect)(updates).to.deep.equal([{ genericCapabilitySelections: undefined }]);
+            expect(updates).to.deep.equal([{ genericCapabilitySelections: undefined }]);
         }
         finally {
             dispose();
@@ -606,10 +601,10 @@ describe('AgentGenericCapabilitiesSettings', () => {
             openEditorAndExpand(container, 'Functions');
             const used = item(container, 'fn-used');
             const checkbox = used.querySelector('input[type=checkbox]');
-            (0, chai_1.expect)(checkbox.checked).to.equal(true);
-            (0, chai_1.expect)(checkbox.disabled).to.equal(true);
-            (0, react_dom_1.flushSync)(() => used.click());
-            (0, chai_1.expect)(updates).to.deep.equal([]);
+            expect(checkbox.checked).to.equal(true);
+            expect(checkbox.disabled).to.equal(true);
+            flushSync(() => used.click());
+            expect(updates).to.deep.equal([]);
         }
         finally {
             dispose();