@codingame/monaco-vscode-testing-service-override 28.4.1 → 29.1.0

package/vscode/src/vs/workbench/contrib/testing/browser/theme.js

@@ -19,36 +19,36 @@ const testingColorIconFailed = registerColor("testing.iconFailed", {
     light: "#f14c4c",
     hcDark: "#f14c4c",
     hcLight: "#B5200D"
-}, ( localize(14236, "Color for the 'failed' icon in the test explorer.")));
+}, ( localize(14498, "Color for the 'failed' icon in the test explorer.")));
 const testingColorIconErrored = registerColor("testing.iconErrored", {
     dark: "#f14c4c",
     light: "#f14c4c",
     hcDark: "#f14c4c",
     hcLight: "#B5200D"
-}, ( localize(14237, "Color for the 'Errored' icon in the test explorer.")));
+}, ( localize(14499, "Color for the 'Errored' icon in the test explorer.")));
 const testingColorIconPassed = registerColor("testing.iconPassed", {
     dark: "#73c991",
     light: "#73c991",
     hcDark: "#73c991",
     hcLight: "#007100"
-}, ( localize(14238, "Color for the 'passed' icon in the test explorer.")));
-const testingColorRunAction = registerColor("testing.runAction", testingColorIconPassed, ( localize(14239, "Color for 'run' icons in the editor.")));
-const testingColorIconQueued = registerColor("testing.iconQueued", "#cca700", ( localize(14240, "Color for the 'Queued' icon in the test explorer.")));
-const testingColorIconUnset = registerColor("testing.iconUnset", "#848484", ( localize(14241, "Color for the 'Unset' icon in the test explorer.")));
-const testingColorIconSkipped = registerColor("testing.iconSkipped", "#848484", ( localize(14242, "Color for the 'Skipped' icon in the test explorer.")));
+}, ( localize(14500, "Color for the 'passed' icon in the test explorer.")));
+const testingColorRunAction = registerColor("testing.runAction", testingColorIconPassed, ( localize(14501, "Color for 'run' icons in the editor.")));
+const testingColorIconQueued = registerColor("testing.iconQueued", "#cca700", ( localize(14502, "Color for the 'Queued' icon in the test explorer.")));
+const testingColorIconUnset = registerColor("testing.iconUnset", "#848484", ( localize(14503, "Color for the 'Unset' icon in the test explorer.")));
+const testingColorIconSkipped = registerColor("testing.iconSkipped", "#848484", ( localize(14504, "Color for the 'Skipped' icon in the test explorer.")));
 const testingPeekBorder = registerColor("testing.peekBorder", {
     dark: editorErrorForeground,
     light: editorErrorForeground,
     hcDark: contrastBorder,
     hcLight: contrastBorder
-}, ( localize(14243, "Color of the peek view borders and arrow.")));
+}, ( localize(14505, "Color of the peek view borders and arrow.")));
 const testingMessagePeekBorder = registerColor("testing.messagePeekBorder", {
     dark: editorInfoForeground,
     light: editorInfoForeground,
     hcDark: contrastBorder,
     hcLight: contrastBorder
 }, ( localize(
-    14244,
+    14506,
     "Color of the peek view borders and arrow when peeking a logged message."
 )));
 const testingPeekHeaderBackground = registerColor("testing.peekHeaderBackground", {
@@ -56,14 +56,14 @@ const testingPeekHeaderBackground = registerColor("testing.peekHeaderBackground"
     light: ( transparent(editorErrorForeground, 0.1)),
     hcDark: null,
     hcLight: null
-}, ( localize(14243, "Color of the peek view borders and arrow.")));
+}, ( localize(14505, "Color of the peek view borders and arrow.")));
 const testingPeekMessageHeaderBackground = registerColor("testing.messagePeekHeaderBackground", {
     dark: ( transparent(editorInfoForeground, 0.1)),
     light: ( transparent(editorInfoForeground, 0.1)),
     hcDark: null,
     hcLight: null
 }, ( localize(
-    14245,
+    14507,
     "Color of the peek view borders and arrow when peeking a logged message."
 )));
 const testingCoveredBackground = registerColor("testing.coveredBackground", {
@@ -71,66 +71,66 @@ const testingCoveredBackground = registerColor("testing.coveredBackground", {
     light: diffInserted,
     hcDark: null,
     hcLight: null
-}, ( localize(14246, "Background color of text that was covered.")));
+}, ( localize(14508, "Background color of text that was covered.")));
 const testingCoveredBorder = registerColor("testing.coveredBorder", {
     dark: ( transparent(testingCoveredBackground, 0.75)),
     light: ( transparent(testingCoveredBackground, 0.75)),
     hcDark: contrastBorder,
     hcLight: contrastBorder
-}, ( localize(14247, "Border color of text that was covered.")));
+}, ( localize(14509, "Border color of text that was covered.")));
 registerColor("testing.coveredGutterBackground", {
     dark: ( transparent(diffInserted, 0.6)),
     light: ( transparent(diffInserted, 0.6)),
     hcDark: chartsGreen,
     hcLight: chartsGreen
-}, ( localize(14248, "Gutter color of regions where code was covered.")));
+}, ( localize(14510, "Gutter color of regions where code was covered.")));
 registerColor("testing.uncoveredBranchBackground", {
     dark: opaque(( transparent(diffRemoved, 2)), editorBackground),
     light: opaque(( transparent(diffRemoved, 2)), editorBackground),
     hcDark: null,
     hcLight: null
-}, ( localize(14249, "Background of the widget shown for an uncovered branch.")));
+}, ( localize(14511, "Background of the widget shown for an uncovered branch.")));
 const testingUncoveredBackground = registerColor("testing.uncoveredBackground", {
     dark: diffRemoved,
     light: diffRemoved,
     hcDark: null,
     hcLight: null
-}, ( localize(14250, "Background color of text that was not covered.")));
+}, ( localize(14512, "Background color of text that was not covered.")));
 const testingUncoveredBorder = registerColor("testing.uncoveredBorder", {
     dark: ( transparent(testingUncoveredBackground, 0.75)),
     light: ( transparent(testingUncoveredBackground, 0.75)),
     hcDark: contrastBorder,
     hcLight: contrastBorder
-}, ( localize(14251, "Border color of text that was not covered.")));
+}, ( localize(14513, "Border color of text that was not covered.")));
 registerColor("testing.uncoveredGutterBackground", {
     dark: ( transparent(diffRemoved, 1.5)),
     light: ( transparent(diffRemoved, 1.5)),
     hcDark: chartsRed,
     hcLight: chartsRed
-}, ( localize(14252, "Gutter color of regions where code not covered.")));
-registerColor("testing.coverCountBadgeBackground", badgeBackground, ( localize(14253, "Background for the badge indicating execution count")));
-registerColor("testing.coverCountBadgeForeground", badgeForeground, ( localize(14254, "Foreground for the badge indicating execution count")));
+}, ( localize(14514, "Gutter color of regions where code not covered.")));
+registerColor("testing.coverCountBadgeBackground", badgeBackground, ( localize(14515, "Background for the badge indicating execution count")));
+registerColor("testing.coverCountBadgeForeground", badgeForeground, ( localize(14516, "Foreground for the badge indicating execution count")));
 const messageBadgeBackground = registerColor(
     "testing.message.error.badgeBackground",
     activityErrorBadgeBackground,
     ( localize(
-    14255,
+    14517,
     "Background color of test error messages shown inline in the editor."
 ))
 );
 registerColor(
     "testing.message.error.badgeBorder",
     messageBadgeBackground,
-    ( localize(14256, "Border color of test error messages shown inline in the editor."))
+    ( localize(14518, "Border color of test error messages shown inline in the editor."))
 );
 registerColor(
     "testing.message.error.badgeForeground",
     activityErrorBadgeForeground,
-    ( localize(14257, "Text color of test error messages shown inline in the editor."))
+    ( localize(14519, "Text color of test error messages shown inline in the editor."))
 );
-registerColor("testing.message.error.lineBackground", null, ( localize(14258, "Margin color beside error messages shown inline in the editor.")));
-registerColor("testing.message.info.decorationForeground", ( transparent(editorForeground, 0.5)), ( localize(14259, "Text color of test info messages shown inline in the editor.")));
-registerColor("testing.message.info.lineBackground", null, ( localize(14260, "Margin color beside info messages shown inline in the editor.")));
+registerColor("testing.message.error.lineBackground", null, ( localize(14520, "Margin color beside error messages shown inline in the editor.")));
+registerColor("testing.message.info.decorationForeground", ( transparent(editorForeground, 0.5)), ( localize(14521, "Text color of test info messages shown inline in the editor.")));
+registerColor("testing.message.info.lineBackground", null, ( localize(14522, "Margin color beside info messages shown inline in the editor.")));
 const testStatesToIconColors = {
     [TestResultState.Errored]: testingColorIconErrored,
     [TestResultState.Failed]: testingColorIconFailed,
@@ -139,12 +139,12 @@ const testStatesToIconColors = {
     [TestResultState.Unset]: testingColorIconUnset,
     [TestResultState.Skipped]: testingColorIconSkipped
 };
-const testingRetiredColorIconErrored = registerColor("testing.iconErrored.retired", ( transparent(testingColorIconErrored, 0.7)), ( localize(14261, "Retired color for the 'Errored' icon in the test explorer.")));
-const testingRetiredColorIconFailed = registerColor("testing.iconFailed.retired", ( transparent(testingColorIconFailed, 0.7)), ( localize(14262, "Retired color for the 'failed' icon in the test explorer.")));
-const testingRetiredColorIconPassed = registerColor("testing.iconPassed.retired", ( transparent(testingColorIconPassed, 0.7)), ( localize(14263, "Retired color for the 'passed' icon in the test explorer.")));
-const testingRetiredColorIconQueued = registerColor("testing.iconQueued.retired", ( transparent(testingColorIconQueued, 0.7)), ( localize(14264, "Retired color for the 'Queued' icon in the test explorer.")));
-const testingRetiredColorIconUnset = registerColor("testing.iconUnset.retired", ( transparent(testingColorIconUnset, 0.7)), ( localize(14265, "Retired color for the 'Unset' icon in the test explorer.")));
-const testingRetiredColorIconSkipped = registerColor("testing.iconSkipped.retired", ( transparent(testingColorIconSkipped, 0.7)), ( localize(14266, "Retired color for the 'Skipped' icon in the test explorer.")));
+const testingRetiredColorIconErrored = registerColor("testing.iconErrored.retired", ( transparent(testingColorIconErrored, 0.7)), ( localize(14523, "Retired color for the 'Errored' icon in the test explorer.")));
+const testingRetiredColorIconFailed = registerColor("testing.iconFailed.retired", ( transparent(testingColorIconFailed, 0.7)), ( localize(14524, "Retired color for the 'failed' icon in the test explorer.")));
+const testingRetiredColorIconPassed = registerColor("testing.iconPassed.retired", ( transparent(testingColorIconPassed, 0.7)), ( localize(14525, "Retired color for the 'passed' icon in the test explorer.")));
+const testingRetiredColorIconQueued = registerColor("testing.iconQueued.retired", ( transparent(testingColorIconQueued, 0.7)), ( localize(14526, "Retired color for the 'Queued' icon in the test explorer.")));
+const testingRetiredColorIconUnset = registerColor("testing.iconUnset.retired", ( transparent(testingColorIconUnset, 0.7)), ( localize(14527, "Retired color for the 'Unset' icon in the test explorer.")));
+const testingRetiredColorIconSkipped = registerColor("testing.iconSkipped.retired", ( transparent(testingColorIconSkipped, 0.7)), ( localize(14528, "Retired color for the 'Skipped' icon in the test explorer.")));
 const testStatesToRetiredIconColors = {
     [TestResultState.Errored]: testingRetiredColorIconErrored,
     [TestResultState.Failed]: testingRetiredColorIconFailed,

package/vscode/src/vs/workbench/contrib/testing/common/configuration.js

@@ -64,46 +64,46 @@ var TestingResultsViewLayout;
 const testingConfiguration = {
     id: "testing",
     order: 21,
-    title: ( localize(14267, "Testing")),
+    title: ( localize(14529, "Testing")),
     type: "object",
     properties: {
         [TestingConfigKeys.AutoOpenPeekView]: {
-            description: ( localize(14268, "Configures when the error Peek view is automatically opened.")),
+            description: ( localize(14530, "Configures when the error Peek view is automatically opened.")),
             enum: [
                 AutoOpenPeekViewWhen.FailureAnywhere,
                 AutoOpenPeekViewWhen.FailureVisible,
                 AutoOpenPeekViewWhen.Never
             ],
             default: AutoOpenPeekViewWhen.Never,
-            enumDescriptions: [( localize(14269, "Open automatically no matter where the failure is.")), ( localize(14270, "Open automatically when a test fails in a visible document.")), ( localize(14271, "Never automatically open."))]
+            enumDescriptions: [( localize(14531, "Open automatically no matter where the failure is.")), ( localize(14532, "Open automatically when a test fails in a visible document.")), ( localize(14533, "Never automatically open."))]
         },
         [TestingConfigKeys.ShowAllMessages]: {
-            description: ( localize(14272, "Controls whether to show messages from all test runs.")),
+            description: ( localize(14534, "Controls whether to show messages from all test runs.")),
             type: "boolean",
             default: false
         },
         [TestingConfigKeys.AutoOpenPeekViewDuringContinuousRun]: {
             description: ( localize(
-                14273,
+                14535,
                 "Controls whether to automatically open the Peek view during continuous run mode."
             )),
             type: "boolean",
             default: false
         },
         [TestingConfigKeys.CountBadge]: {
-            description: ( localize(14274, "Controls the count badge on the Testing icon on the Activity Bar.")),
+            description: ( localize(14536, "Controls the count badge on the Testing icon on the Activity Bar.")),
             enum: [
                 TestingCountBadge.Failed,
                 TestingCountBadge.Off,
                 TestingCountBadge.Passed,
                 TestingCountBadge.Skipped
             ],
-            enumDescriptions: [( localize(14275, "Show the number of failed tests")), ( localize(14276, "Disable the testing count badge")), ( localize(14277, "Show the number of passed tests")), ( localize(14278, "Show the number of skipped tests"))],
+            enumDescriptions: [( localize(14537, "Show the number of failed tests")), ( localize(14538, "Disable the testing count badge")), ( localize(14539, "Show the number of passed tests")), ( localize(14540, "Show the number of skipped tests"))],
             default: TestingCountBadge.Failed
         },
         [TestingConfigKeys.FollowRunningTest]: {
             description: ( localize(
-                14279,
+                14541,
                 "Controls whether the running test should be followed in the Test Explorer view."
             )),
             type: "boolean",
@@ -111,7 +111,7 @@ const testingConfiguration = {
         },
         [TestingConfigKeys.DefaultGutterClickAction]: {
             description: ( localize(
-                14280,
+                14542,
                 "Controls the action to take when left-clicking on a test decoration in the gutter."
             )),
             enum: [
@@ -120,16 +120,16 @@ const testingConfiguration = {
                 DefaultGutterClickAction.Coverage,
                 DefaultGutterClickAction.ContextMenu
             ],
-            enumDescriptions: [( localize(14281, "Run the test.")), ( localize(14282, "Debug the test.")), ( localize(14283, "Run the test with coverage.")), ( localize(14284, "Open the context menu for more options."))],
+            enumDescriptions: [( localize(14543, "Run the test.")), ( localize(14544, "Debug the test.")), ( localize(14545, "Run the test with coverage.")), ( localize(14546, "Open the context menu for more options."))],
             default: DefaultGutterClickAction.Run
         },
         [TestingConfigKeys.GutterEnabled]: {
-            description: ( localize(14285, "Controls whether test decorations are shown in the editor gutter.")),
+            description: ( localize(14547, "Controls whether test decorations are shown in the editor gutter.")),
             type: "boolean",
             default: true
         },
         [TestingConfigKeys.SaveBeforeTest]: {
-            description: ( localize(14286, "Control whether save all dirty editors before running a test.")),
+            description: ( localize(14548, "Control whether save all dirty editors before running a test.")),
             type: "boolean",
             default: true
         },
@@ -140,13 +140,13 @@ const testingConfiguration = {
                 AutoOpenTesting.OpenOnTestFailure,
                 AutoOpenTesting.OpenExplorerOnTestStart
             ],
-            enumDescriptions: [( localize(14287, "Never automatically open the testing views")), ( localize(14288, "Open the test results view when tests start")), ( localize(14289, "Open the test result view on any test failure")), ( localize(14290, "Open the test explorer when tests start"))],
+            enumDescriptions: [( localize(14549, "Never automatically open the testing views")), ( localize(14550, "Open the test results view when tests start")), ( localize(14551, "Open the test result view on any test failure")), ( localize(14552, "Open the test explorer when tests start"))],
             default: "openOnTestStart",
-            description: ( localize(14291, "Controls when the testing view should open."))
+            description: ( localize(14553, "Controls when the testing view should open."))
         },
         [TestingConfigKeys.AlwaysRevealTestOnStateChange]: {
             markdownDescription: ( localize(
-                14292,
+                14554,
                 "Always reveal the executed test when {0} is on. If this setting is turned off, only failed tests will be revealed.",
                 "`#testing.followRunningTest#`"
             )),
@@ -154,13 +154,13 @@ const testingConfiguration = {
             default: false
         },
         [TestingConfigKeys.ShowCoverageInExplorer]: {
-            description: ( localize(14293, "Whether test coverage should be down in the File Explorer view.")),
+            description: ( localize(14555, "Whether test coverage should be down in the File Explorer view.")),
             type: "boolean",
             default: true
         },
         [TestingConfigKeys.CoveragePercent]: {
             markdownDescription: ( localize(
-                14294,
+                14556,
                 "Configures what percentage is displayed by default for test coverage."
             )),
             default: TestingDisplayedCoveragePercent.TotalCoverage,
@@ -170,12 +170,12 @@ const testingConfiguration = {
                 TestingDisplayedCoveragePercent.Minimum
             ],
             enumDescriptions: [( localize(
-                14295,
+                14557,
                 "A calculation of the combined statement, function, and branch coverage."
-            )), ( localize(14296, "The statement coverage.")), ( localize(14297, "The minimum of statement, function, and branch coverage."))]
+            )), ( localize(14558, "The statement coverage.")), ( localize(14559, "The minimum of statement, function, and branch coverage."))]
         },
         [TestingConfigKeys.CoverageBarThresholds]: {
-            markdownDescription: ( localize(14298, "Configures the colors used for percentages in test coverage bars.")),
+            markdownDescription: ( localize(14560, "Configures the colors used for percentages in test coverage bars.")),
             default: {
                 red: 0,
                 yellow: 60,
@@ -203,18 +203,18 @@ const testingConfiguration = {
             }
         },
         [TestingConfigKeys.CoverageToolbarEnabled]: {
-            description: ( localize(14299, "Controls whether the coverage toolbar is shown in the editor.")),
+            description: ( localize(14561, "Controls whether the coverage toolbar is shown in the editor.")),
             type: "boolean",
             default: false
         },
         [TestingConfigKeys.ResultsViewLayout]: {
-            description: ( localize(14300, "Controls the layout of the Test Results view.")),
+            description: ( localize(14562, "Controls the layout of the Test Results view.")),
             enum: [TestingResultsViewLayout.TreeRight, TestingResultsViewLayout.TreeLeft],
             enumDescriptions: [( localize(
-                14301,
+                14563,
                 "Show the test run tree on the right side with details on the left."
             )), ( localize(
-                14302,
+                14564,
                 "Show the test run tree on the left side with details on the right."
             ))],
             default: TestingResultsViewLayout.TreeRight

package/vscode/src/vs/workbench/contrib/testing/common/testResultService.d.ts

@@ -41,7 +41,7 @@ export declare class TestResultService extends Disposable implements ITestResult
     private readonly isRunning;
     private readonly hasAnyResults;
     private readonly loadResults;
-    protected readonly persistScheduler: RunOnceScheduler;
+    protected readonly persistScheduler: RunOnceScheduler<() => Promise<void>>;
     constructor(contextKeyService: IContextKeyService, storage: ITestResultStorage, testProfiles: ITestProfileService, telemetryService: ITelemetryService);
     /**
      * @inheritdoc

package/vscode/src/vs/workbench/contrib/testing/common/testServiceImpl.js

@@ -164,7 +164,7 @@ let TestService = class TestService extends Disposable {
             req.exclude = [...this.excluded.all];
         }
         const trust = await this.workspaceTrustRequestService.requestWorkspaceTrust({
-            message: ( localize(14316, "Running tests may execute code in your workspace."))
+            message: ( localize(14578, "Running tests may execute code in your workspace."))
         });
         if (!trust) {
             return;
@@ -179,7 +179,7 @@ let TestService = class TestService extends Disposable {
             }))), token).then(result => {
                 const errs = ( result.map(r => r.error)).filter(isDefined);
                 if (errs.length) {
-                    this.notificationService.error(( localize(14317, "An error occurred attempting to run tests: {0}", errs.join(" "))));
+                    this.notificationService.error(( localize(14579, "An error occurred attempting to run tests: {0}", errs.join(" "))));
                 }
             })
         ));
@@ -191,7 +191,7 @@ let TestService = class TestService extends Disposable {
         }
         const result = this.testResults.createLiveResult(req);
         const trust = await this.workspaceTrustRequestService.requestWorkspaceTrust({
-            message: ( localize(14316, "Running tests may execute code in your workspace."))
+            message: ( localize(14578, "Running tests may execute code in your workspace."))
         });
         if (!trust) {
             result.markComplete();
@@ -211,7 +211,7 @@ let TestService = class TestService extends Disposable {
                 }))), cancelSource.token).then(result => {
                     const errs = ( result.map(r => r.error)).filter(isDefined);
                     if (errs.length) {
-                        this.notificationService.error(( localize(14317, "An error occurred attempting to run tests: {0}", errs.join(" "))));
+                        this.notificationService.error(( localize(14579, "An error occurred attempting to run tests: {0}", errs.join(" "))));
                     }
                 })
             ));

package/vscode/src/vs/workbench/contrib/testing/common/testingChatAgentTool.d.ts

@@ -1,9 +1,60 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
 import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
 import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
+import { FileCoverage, TestCoverage } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/testing/common/testCoverage";
+import { LiveTestResult } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/testing/common/testResult";
+import { ITestResultService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/testing/common/testResultService.service";
+import { ITestService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/testing/common/testService.service";
+import { ITestProfileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/testing/common/testProfileService.service";
 export declare class TestingChatAgentToolContribution extends Disposable implements IWorkbenchContribution {
     static readonly ID = "workbench.contrib.testing.chatAgentTool";
     constructor(instantiationService: IInstantiationService, toolsService: ILanguageModelToolsService, contextKeyService: IContextKeyService);
 }
+type Mode = "run" | "coverage";
+export declare class RunTestTool implements IToolImpl {
+    private readonly _testService;
+    private readonly _uriIdentityService;
+    private readonly _workspaceContextService;
+    private readonly _testResultService;
+    private readonly _testProfileService;
+    static readonly ID = "runTests";
+    static readonly DEFINITION: IToolData;
+    constructor(_testService: ITestService, _uriIdentityService: IUriIdentityService, _workspaceContextService: IWorkspaceContextService, _testResultService: ITestResultService, _testProfileService: ITestProfileService);
+    invoke(invocation: IToolInvocation, countTokens: CountTokensCallback, progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
+    /** Updates the UI progress as the test runs, resolving when the run is finished. */
+    private _monitorRunProgress;
+    /**
+     * Captures the test result. This is a little tricky because some extensions
+     * trigger an 'out of bound' test run, so we actually wait for the first
+     * test run to come in that contains one or more tasks and treat that as the
+     * one we're looking for.
+     */
+    private _captureTestResult;
+    /** Filters the test files to individual test cases based on the provided parameters. */
+    private _getTestCasesToRun;
+    /** Gets the file tests to run based on the provided parameters. */
+    private _getFileTestsToRun;
+    prepareToolInvocation(context: IToolInvocationPreparationContext, token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+}
+/** Builds the full summary string for a completed test run. */
+export declare function buildTestRunSummary(result: LiveTestResult, mode: Mode, coverageFiles: string[] | undefined): Promise<string>;
+/** Gets a coverage summary from a test result, either overall or per-file. */
+export declare function getCoverageSummary(result: LiveTestResult, coverageFiles: string[] | undefined): Promise<string>;
+/** Gets a file-level coverage overview sorted by lowest coverage first. */
+export declare function getOverallCoverageSummary(coverage: TestCoverage): string;
+/** Gets detailed coverage information for a single file including uncovered items. */
+export declare function getFileCoverageDetails(file: FileCoverage, path: string): Promise<string>;
+/** Merges overlapping/contiguous line ranges and formats them compactly. */
+export declare function mergeLineRanges(ranges: [
+    number,
+    number
+][]): string;
+/** Formats failure details from a test result into an XML-like string. */
+export declare function getFailureDetails(result: LiveTestResult): Promise<string>;
+export {};