@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/taskHelpers.js

@@ -10,25 +10,26 @@ import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event'
 import { isString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 
 function getTaskDefinition(id) {
-    const idx = id.indexOf(': ');
+    const idx = id.indexOf(": ");
     const taskType = id.substring(0, idx);
     let taskLabel = idx > 0 ? id.substring(idx + 2) : id;
     if (/^\d+$/.test(taskLabel)) {
         taskLabel = id;
     }
-    return { taskLabel, taskType };
+    return {
+        taskLabel,
+        taskType
+    };
 }
 function getTaskRepresentation(task) {
-    if ('label' in task && task.label) {
+    if ("label" in task && task.label) {
         return task.label;
-    }
-    else if ('script' in task && task.script) {
+    } else if ("script" in task && task.script) {
         return task.script;
+    } else if ("command" in task && task.command) {
+        return isString(task.command) ? task.command : task.command.name?.toString() || "";
     }
-    else if ('command' in task && task.command) {
-        return isString(task.command) ? task.command : task.command.name?.toString() || '';
-    }
-    return '';
+    return "";
 }
 function getTaskKey(task) {
     return task.getKey() ?? task.getMapKey();
@@ -45,27 +46,34 @@ function tasksMatch(a, b) {
     }
     return a._id === b._id;
 }
-async function getTaskForTool(id, taskDefinition, workspaceFolder, configurationService, taskService, allowParentTask) {
+async function getTaskForTool(
+    id,
+    taskDefinition,
+    workspaceFolder,
+    configurationService,
+    taskService,
+    allowParentTask
+) {
     let index = 0;
     let task;
     const workspaceFolderToTaskMap = await taskService.getWorkspaceTasks();
     let configTasks = [];
     for (const folder of ( workspaceFolderToTaskMap.keys())) {
-        const tasksConfig = configurationService.getValue('tasks', { resource: ( URI.parse(folder)) });
+        const tasksConfig = configurationService.getValue("tasks", {
+            resource: ( URI.parse(folder))
+        });
         if (tasksConfig?.tasks) {
             configTasks = configTasks.concat(tasksConfig.tasks);
         }
     }
     for (const configTask of configTasks) {
-        if ((!allowParentTask && !configTask.type) || ('hide' in configTask && configTask.hide)) {
+        if ((!allowParentTask && !configTask.type) || ("hide" in configTask && configTask.hide)) {
             continue;
         }
-        if ((configTask.type && taskDefinition.taskType ? configTask.type === taskDefinition.taskType : true) &&
-            ((getTaskRepresentation(configTask) === taskDefinition?.taskLabel) || (id === configTask.label))) {
+        if ((configTask.type && taskDefinition.taskType ? configTask.type === taskDefinition.taskType : true) && ((getTaskRepresentation(configTask) === taskDefinition?.taskLabel) || (id === configTask.label))) {
             task = configTask;
             break;
-        }
-        else if (!configTask.label && id === `${configTask.type}: ${index}`) {
+        } else if (!configTask.label && id === `${configTask.type}: ${index}`) {
             task = configTask;
             break;
         }
@@ -103,16 +111,29 @@ async function resolveDependencyTasks(parentTask, workspaceFolder, configuration
     if (!parentTask.configurationProperties?.dependsOn) {
         return undefined;
     }
-    const dependencyTasks = await Promise.all(( parentTask.configurationProperties.dependsOn.map(async (dep) => {
+    const dependencyTasks = await Promise.all(( parentTask.configurationProperties.dependsOn.map(async dep => {
         const depId = isString(dep.task) ? dep.task : dep.task?._key;
         if (!depId) {
             return undefined;
         }
-        return await getTaskForTool(depId, { taskLabel: depId }, workspaceFolder, configurationService, taskService);
+        return await getTaskForTool(depId, {
+            taskLabel: depId
+        }, workspaceFolder, configurationService, taskService);
     })));
-    return dependencyTasks.filter((t) => t !== undefined);
+    return dependencyTasks.filter(t => t !== undefined);
 }
-async function collectTerminalResults(terminals, task, instantiationService, invocationContext, progress, token, disposableStore, isActive, dependencyTasks, taskService) {
+async function collectTerminalResults(
+    terminals,
+    task,
+    instantiationService,
+    invocationContext,
+    progress,
+    token,
+    disposableStore,
+    isActive,
+    dependencyTasks,
+    taskService
+) {
     const results = [];
     if (token.isCancellationRequested) {
         return results;
@@ -125,30 +146,30 @@ async function collectTerminalResults(terminals, task, instantiationService, inv
         taskIdToTaskMap[dependencyTask._id] = dependencyTask;
         taskLabelToTaskMap[dependencyTask._label] = dependencyTask;
     }
-    for (const instance of terminals) {
-        progress.report({ message: ( new MarkdownString(`Checking output for \`${instance.shellLaunchConfig.name ?? 'unknown'}\``)) });
+    const terminalNames = ( terminals.map(t => t.shellLaunchConfig.name ?? t.title ?? "unknown"));
+    progress.report({
+        message: ( new MarkdownString(`Checking output for ${( terminalNames.map(n => `\`${n}\``)).join(", ")}`))
+    });
+    const terminalPromises = ( terminals.map(async instance => {
         let terminalTask = task;
         if (dependencyTasks?.length) {
             const reconnectionData = instance.reconnectionProperties?.data;
             if (reconnectionData) {
                 if (reconnectionData.lastTask in commonTaskIdToTaskMap) {
                     terminalTask = commonTaskIdToTaskMap[reconnectionData.lastTask];
-                }
-                else if (reconnectionData.id in taskIdToTaskMap) {
+                } else if (reconnectionData.id in taskIdToTaskMap) {
                     terminalTask = taskIdToTaskMap[reconnectionData.id];
                 }
-            }
-            else {
+            } else {
                 if (instance.shellLaunchConfig.name && instance.shellLaunchConfig.name in taskLabelToTaskMap) {
                     terminalTask = taskLabelToTaskMap[instance.shellLaunchConfig.name];
-                }
-                else if (instance.title in taskLabelToTaskMap) {
+                } else if (instance.title in taskLabelToTaskMap) {
                     terminalTask = taskLabelToTaskMap[instance.title];
                 }
             }
         }
         const execution = {
-            getOutput: () => getOutput(instance) ?? '',
+            getOutput: () => getOutput(instance) ?? "",
             task: terminalTask,
             isActive: isActive ? () => isActive(terminalTask) : undefined,
             instance,
@@ -166,12 +187,22 @@ async function collectTerminalResults(terminals, task, instantiationService, inv
                 await timeout(100);
             }
         }
-        const outputMonitor = disposableStore.add(instantiationService.createInstance(OutputMonitor, execution, taskProblemPollFn, invocationContext, token, task._label));
-        await Event.toPromise(outputMonitor.onDidFinishCommand);
+        const outputMonitor = disposableStore.add(instantiationService.createInstance(
+            OutputMonitor,
+            execution,
+            taskProblemPollFn,
+            invocationContext,
+            token,
+            task._label
+        ));
+        await Promise.race([
+            Event.toPromise(outputMonitor.onDidFinishCommand),
+            Event.toPromise(token.onCancellationRequested)
+        ]);
         const pollingResult = outputMonitor.pollingResult;
-        results.push({
-            name: instance.shellLaunchConfig.name ?? instance.title ?? 'unknown',
-            output: pollingResult?.output ?? '',
+        return {
+            name: instance.shellLaunchConfig.name ?? instance.title ?? "unknown",
+            output: pollingResult?.output ?? "",
             pollDurationMs: pollingResult?.pollDurationMs ?? 0,
             resources: pollingResult?.resources,
             state: pollingResult?.state || OutputMonitorState.Idle,
@@ -182,9 +213,11 @@ async function collectTerminalResults(terminals, task, instantiationService, inv
             inputToolAutoChars: outputMonitor.outputMonitorTelemetryCounters.inputToolAutoChars ?? 0,
             inputToolManualShownCount: outputMonitor.outputMonitorTelemetryCounters.inputToolManualShownCount ?? 0,
             inputToolFreeFormInputShownCount: outputMonitor.outputMonitorTelemetryCounters.inputToolFreeFormInputShownCount ?? 0,
-            inputToolFreeFormInputCount: outputMonitor.outputMonitorTelemetryCounters.inputToolFreeFormInputCount ?? 0,
-        });
-    }
+            inputToolFreeFormInputCount: outputMonitor.outputMonitorTelemetryCounters.inputToolFreeFormInputCount ?? 0
+        };
+    }));
+    const parallelResults = await Promise.all(terminalPromises);
+    results.push(...parallelResults);
     return results;
 }
 async function taskProblemPollFn(execution, token, taskService) {
@@ -196,40 +229,43 @@ async function taskProblemPollFn(execution, token, taskService) {
         if (data) {
             const problemList = [];
             const resultResources = [];
-            for (const [owner, { resources, markers }] of data.entries()) {
+            for (const [owner, {
+                resources,
+                markers
+            }] of data.entries()) {
                 for (let i = 0; i < markers.length; i++) {
                     const uri = resources[i];
                     const marker = markers[i];
                     resultResources.push({
                         uri,
-                        range: marker.startLineNumber !== undefined && marker.startColumn !== undefined && marker.endLineNumber !== undefined && marker.endColumn !== undefined
-                            ? ( new Range(
+                        range: marker.startLineNumber !== undefined && marker.startColumn !== undefined && marker.endLineNumber !== undefined && marker.endColumn !== undefined ? ( new Range(
                             marker.startLineNumber,
                             marker.startColumn,
                             marker.endLineNumber,
                             marker.endColumn
-                        ))
-                            : undefined
+                        )) : undefined
                     });
-                    const message = marker.message ?? '';
-                    problemList.push(`Problem: ${message} in ${uri.fsPath} coming from ${owner} starting on line ${marker.startLineNumber}${marker.startColumn ? `, column ${marker.startColumn} and ending on line ${marker.endLineNumber}${marker.endColumn ? `, column ${marker.endColumn}` : ''}` : ''}`);
+                    const message = marker.message ?? "";
+                    problemList.push(
+                        `Problem: ${message} in ${uri.fsPath} coming from ${owner} starting on line ${marker.startLineNumber}${marker.startColumn ? `, column ${marker.startColumn} and ending on line ${marker.endLineNumber}${marker.endColumn ? `, column ${marker.endColumn}` : ""}` : ""}`
+                    );
                 }
             }
             if (problemList.length === 0) {
-                const lastTenLines = execution.getOutput().split('\n').filter(line => line !== '').slice(-10).join('\n');
+                const lastTenLines = execution.getOutput().split("\n").filter(line => line !== "").slice(-10).join("\n");
                 return {
                     state: OutputMonitorState.Idle,
-                    output: `Task completed with output:\n${lastTenLines}`,
+                    output: `Task completed with output:\n${lastTenLines}`
                 };
             }
             return {
                 state: OutputMonitorState.Idle,
-                output: problemList.join('\n'),
-                resources: resultResources,
+                output: problemList.join("\n"),
+                resources: resultResources
             };
         }
     }
-    throw ( new Error('Polling failed'));
+    throw ( new Error("Polling failed"));
 }
 
 export { collectTerminalResults, getTaskDefinition, getTaskForTool, getTaskKey, getTaskRepresentation, resolveDependencyTasks, taskProblemPollFn, tasksMatch };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/terminal.chatAgentTools.contribution.js

@@ -18,7 +18,9 @@ import { TerminalContextMenuGroup } from '@codingame/monaco-vscode-api/vscode/vs
 import { TerminalContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminalContextKey';
 import { TerminalChatAgentToolsCommandId } from '../common/terminal.chatAgentTools.js';
 import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
+import { AwaitTerminalTool, AwaitTerminalToolData } from './tools/awaitTerminalTool.js';
 import { GetTerminalLastCommandTool, GetTerminalLastCommandToolData } from './tools/getTerminalLastCommandTool.js';
+import { KillTerminalTool, KillTerminalToolData } from './tools/killTerminalTool.js';
 import { GetTerminalOutputTool, GetTerminalOutputToolData } from './tools/getTerminalOutputTool.js';
 import { GetTerminalSelectionTool, GetTerminalSelectionToolData } from './tools/getTerminalSelectionTool.js';
 import { ConfirmTerminalCommandTool, ConfirmTerminalCommandToolData } from './tools/runInTerminalConfirmationTool.js';
@@ -26,9 +28,13 @@ import { createRunInTerminalToolData, RunInTerminalTool } from './tools/runInTer
 import { CreateAndRunTaskTool, CreateAndRunTaskToolData } from './tools/task/createAndRunTaskTool.js';
 import { GetTaskOutputTool, GetTaskOutputToolData } from './tools/task/getTaskOutputTool.js';
 import { RunTaskTool, RunTaskToolData } from './tools/task/runTaskTool.js';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import '../common/terminalSandboxService.js';
 
 let ShellIntegrationTimeoutMigrationContribution = class ShellIntegrationTimeoutMigrationContribution extends Disposable {
-    static { this.ID = 'terminal.shellIntegrationTimeoutMigration'; }
+    static {
+        this.ID = "terminal.shellIntegrationTimeoutMigration";
+    }
     constructor(configurationService) {
         super();
         const deprecatedSettingValue = configurationService.getValue(TerminalChatAgentToolsSettingId.ShellIntegrationTimeout);
@@ -41,28 +47,64 @@ let ShellIntegrationTimeoutMigrationContribution = class ShellIntegrationTimeout
         }
     }
 };
-ShellIntegrationTimeoutMigrationContribution = ( __decorate([
-    ( __param(0, IConfigurationService))
-], ShellIntegrationTimeoutMigrationContribution));
-registerWorkbenchContribution2(ShellIntegrationTimeoutMigrationContribution.ID, ShellIntegrationTimeoutMigrationContribution, WorkbenchPhase.Eventually);
+ShellIntegrationTimeoutMigrationContribution = ( __decorate([( __param(0, IConfigurationService))], ShellIntegrationTimeoutMigrationContribution));
+registerWorkbenchContribution2(
+    ShellIntegrationTimeoutMigrationContribution.ID,
+    ShellIntegrationTimeoutMigrationContribution,
+    WorkbenchPhase.Eventually
+);
+let OutputLocationMigrationContribution = class OutputLocationMigrationContribution extends Disposable {
+    static {
+        this.ID = "terminal.outputLocationMigration";
+    }
+    constructor(configurationService) {
+        super();
+        const currentValue = configurationService.getValue(TerminalChatAgentToolsSettingId.OutputLocation);
+        if (currentValue === "none") {
+            configurationService.updateValue(TerminalChatAgentToolsSettingId.OutputLocation, "chat");
+        }
+    }
+};
+OutputLocationMigrationContribution = ( __decorate([( __param(0, IConfigurationService))], OutputLocationMigrationContribution));
+registerWorkbenchContribution2(
+    OutputLocationMigrationContribution.ID,
+    OutputLocationMigrationContribution,
+    WorkbenchPhase.Eventually
+);
 let ChatAgentToolsContribution = class ChatAgentToolsContribution extends Disposable {
-    static { this.ID = 'terminal.chatAgentTools'; }
+    static {
+        this.ID = "terminal.chatAgentTools";
+    }
     constructor(instantiationService, toolsService) {
         super();
         const confirmTerminalCommandTool = instantiationService.createInstance(ConfirmTerminalCommandTool);
-        this._register(toolsService.registerTool(ConfirmTerminalCommandToolData, confirmTerminalCommandTool));
+        this._register(
+            toolsService.registerTool(ConfirmTerminalCommandToolData, confirmTerminalCommandTool)
+        );
         const getTerminalOutputTool = instantiationService.createInstance(GetTerminalOutputTool);
-        this._register(toolsService.registerTool(GetTerminalOutputToolData, getTerminalOutputTool));
+        this._register(
+            toolsService.registerTool(GetTerminalOutputToolData, getTerminalOutputTool)
+        );
         this._register(toolsService.executeToolSet.addTool(GetTerminalOutputToolData));
+        const awaitTerminalTool = instantiationService.createInstance(AwaitTerminalTool);
+        this._register(toolsService.registerTool(AwaitTerminalToolData, awaitTerminalTool));
+        this._register(toolsService.executeToolSet.addTool(AwaitTerminalToolData));
+        const killTerminalTool = instantiationService.createInstance(KillTerminalTool);
+        this._register(toolsService.registerTool(KillTerminalToolData, killTerminalTool));
+        this._register(toolsService.executeToolSet.addTool(KillTerminalToolData));
         instantiationService.invokeFunction(createRunInTerminalToolData).then(runInTerminalToolData => {
             const runInTerminalTool = instantiationService.createInstance(RunInTerminalTool);
             this._register(toolsService.registerTool(runInTerminalToolData, runInTerminalTool));
             this._register(toolsService.executeToolSet.addTool(runInTerminalToolData));
         });
         const getTerminalSelectionTool = instantiationService.createInstance(GetTerminalSelectionTool);
-        this._register(toolsService.registerTool(GetTerminalSelectionToolData, getTerminalSelectionTool));
+        this._register(
+            toolsService.registerTool(GetTerminalSelectionToolData, getTerminalSelectionTool)
+        );
         const getTerminalLastCommandTool = instantiationService.createInstance(GetTerminalLastCommandTool);
-        this._register(toolsService.registerTool(GetTerminalLastCommandToolData, getTerminalLastCommandTool));
+        this._register(
+            toolsService.registerTool(GetTerminalLastCommandToolData, getTerminalLastCommandTool)
+        );
         this._register(toolsService.readToolSet.addTool(GetTerminalSelectionToolData));
         this._register(toolsService.readToolSet.addTool(GetTerminalLastCommandToolData));
         const runTaskTool = instantiationService.createInstance(RunTaskTool);
@@ -76,23 +118,22 @@ let ChatAgentToolsContribution = class ChatAgentToolsContribution extends Dispos
         this._register(toolsService.readToolSet.addTool(GetTaskOutputToolData));
     }
 };
-ChatAgentToolsContribution = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, ILanguageModelToolsService))
-], ChatAgentToolsContribution));
-registerWorkbenchContribution2(ChatAgentToolsContribution.ID, ChatAgentToolsContribution, WorkbenchPhase.AfterRestored);
+ChatAgentToolsContribution = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, ILanguageModelToolsService))], ChatAgentToolsContribution));
+registerWorkbenchContribution2(
+    ChatAgentToolsContribution.ID,
+    ChatAgentToolsContribution,
+    WorkbenchPhase.AfterRestored
+);
 registerActiveInstanceAction({
     id: TerminalChatAgentToolsCommandId.ChatAddTerminalSelection,
-    title: ( localize(12020, 'Add Terminal Selection to Chat')),
+    title: ( localize(12348, "Add Terminal Selection to Chat")),
     precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, sharedWhenClause.terminalAvailable)),
-    menu: [
-        {
-            id: MenuId.TerminalInstanceContext,
-            group: TerminalContextMenuGroup.Chat,
-            order: 1,
-            when: ( ContextKeyExpr.and(ChatContextKeys.enabled, TerminalContextKeys.textSelected))
-        },
-    ],
+    menu: [{
+        id: MenuId.TerminalInstanceContext,
+        group: TerminalContextMenuGroup.Chat,
+        order: 1,
+        when: ( ContextKeyExpr.and(ChatContextKeys.enabled, TerminalContextKeys.textSelected))
+    }],
     run: async (activeInstance, _c, accessor) => {
         const chatWidgetService = accessor.get(IChatWidgetService);
         const selection = activeInstance.selection;
@@ -105,9 +146,9 @@ registerActiveInstanceAction({
         }
         chatView.attachmentModel.addContext({
             id: `terminal-selection-${Date.now()}`,
-            kind: 'generic',
-            name: ( localize(12021, 'Terminal Selection')),
-            fullName: ( localize(12021, 'Terminal Selection')),
+            kind: "generic",
+            name: ( localize(12349, "Terminal Selection")),
+            fullName: ( localize(12349, "Terminal Selection")),
             value: selection,
             icon: Codicon.terminal
         });

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/toolTerminalCreator.d.ts

@@ -14,6 +14,7 @@ export interface IToolTerminal {
     instance: ITerminalInstance;
     shellIntegrationQuality: ShellIntegrationQuality;
     receivedUserInput?: boolean;
+    isBackground?: boolean;
 }
 export declare class ToolTerminalCreator {
     private readonly _configurationService;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/toolTerminalCreator.js

@@ -19,20 +19,24 @@ import { isBash, isZsh, isFish, isPowerShell } from './runInTerminalHelpers.js';
 
 var ToolTerminalCreator_1;
 var ShellLaunchType;
-(function (ShellLaunchType) {
+(function(ShellLaunchType) {
     ShellLaunchType[ShellLaunchType["Unknown"] = 0] = "Unknown";
     ShellLaunchType[ShellLaunchType["Default"] = 1] = "Default";
     ShellLaunchType[ShellLaunchType["Fallback"] = 2] = "Fallback";
 })(ShellLaunchType || (ShellLaunchType = {}));
 var ShellIntegrationQuality;
-(function (ShellIntegrationQuality) {
+(function(ShellIntegrationQuality) {
     ShellIntegrationQuality["None"] = "none";
     ShellIntegrationQuality["Basic"] = "basic";
     ShellIntegrationQuality["Rich"] = "rich";
 })(ShellIntegrationQuality || (ShellIntegrationQuality = {}));
 let ToolTerminalCreator = class ToolTerminalCreator {
-    static { ToolTerminalCreator_1 = this; }
-    static { this._lastSuccessfulShell = ShellLaunchType.Unknown; }
+    static {
+        ToolTerminalCreator_1 = this;
+    }
+    static {
+        this._lastSuccessfulShell = ShellLaunchType.Unknown;
+    }
     constructor(_configurationService, _logService, _terminalService) {
         this._configurationService = _configurationService;
         this._logService = _logService;
@@ -42,21 +46,29 @@ let ToolTerminalCreator = class ToolTerminalCreator {
         const instance = await this._createCopilotTerminal(shellOrProfile, os);
         const toolTerminal = {
             instance,
-            shellIntegrationQuality: ShellIntegrationQuality.None,
+            shellIntegrationQuality: ShellIntegrationQuality.None
         };
         let processReadyTimestamp = 0;
         const initResult = await Promise.any([
             instance.processReady.then(() => processReadyTimestamp = Date.now()),
-            Event.toPromise(instance.onExit),
+            Event.toPromise(instance.onExit)
         ]);
-        if (!isNumber(initResult) && isObject(initResult) && hasKey(initResult, { message: true })) {
+        if (!isNumber(initResult) && isObject(initResult) && hasKey(initResult, {
+            message: true
+        })) {
             throw ( new Error(initResult.message));
         }
         const siInjectionEnabled = this._configurationService.getValue(TerminalSettingId.ShellIntegrationEnabled) === true;
-        const waitTime = getShellIntegrationTimeout(this._configurationService, siInjectionEnabled, instance.hasRemoteAuthority, processReadyTimestamp);
-        if (ToolTerminalCreator_1._lastSuccessfulShell !== ShellLaunchType.Fallback ||
-            siInjectionEnabled) {
-            this._logService.info(`ToolTerminalCreator#createTerminal: Waiting ${waitTime}ms for shell integration`);
+        const waitTime = getShellIntegrationTimeout(
+            this._configurationService,
+            siInjectionEnabled,
+            instance.hasRemoteAuthority,
+            processReadyTimestamp
+        );
+        if (ToolTerminalCreator_1._lastSuccessfulShell !== ShellLaunchType.Fallback || siInjectionEnabled) {
+            this._logService.info(
+                `ToolTerminalCreator#createTerminal: Waiting ${waitTime}ms for shell integration`
+            );
             const shellIntegrationQuality = await this._waitForShellIntegration(instance, waitTime);
             if (token.isCancellationRequested) {
                 instance.dispose();
@@ -65,10 +77,14 @@ let ToolTerminalCreator = class ToolTerminalCreator {
             if (shellIntegrationQuality === ShellIntegrationQuality.Rich) {
                 const commandDetection = instance.capabilities.get(TerminalCapability.CommandDetection);
                 if (commandDetection?.promptInputModel.state === PromptInputState.Unknown) {
-                    this._logService.info(`ToolTerminalCreator#createTerminal: Waiting up to 2s for PromptInputModel state to change`);
+                    this._logService.info(
+                        `ToolTerminalCreator#createTerminal: Waiting up to 2s for PromptInputModel state to change`
+                    );
                     const didStart = await raceTimeout(Event.toPromise(commandDetection.onCommandStarted), 2000);
                     if (!didStart) {
-                        this._logService.info(`ToolTerminalCreator#createTerminal: PromptInputModel state did not change within timeout`);
+                        this._logService.info(
+                            `ToolTerminalCreator#createTerminal: PromptInputModel state did not change within timeout`
+                        );
                     }
                 }
             }
@@ -77,9 +93,10 @@ let ToolTerminalCreator = class ToolTerminalCreator {
                 toolTerminal.shellIntegrationQuality = shellIntegrationQuality;
                 return toolTerminal;
             }
-        }
-        else {
-            this._logService.info(`ToolTerminalCreator#createTerminal: Skipping wait for shell integration - last successful launch type ${ToolTerminalCreator_1._lastSuccessfulShell}`);
+        } else {
+            this._logService.info(
+                `ToolTerminalCreator#createTerminal: Skipping wait for shell integration - last successful launch type ${ToolTerminalCreator_1._lastSuccessfulShell}`
+            );
         }
         ToolTerminalCreator_1._lastSuccessfulShell = ShellLaunchType.Fallback;
         return toolTerminal;
@@ -87,8 +104,7 @@ let ToolTerminalCreator = class ToolTerminalCreator {
     refreshShellIntegrationQuality(toolTerminal) {
         const commandDetection = toolTerminal.instance.capabilities.get(TerminalCapability.CommandDetection);
         if (commandDetection) {
-            if (toolTerminal.shellIntegrationQuality === ShellIntegrationQuality.None ||
-                toolTerminal.shellIntegrationQuality === ShellIntegrationQuality.Basic) {
+            if (toolTerminal.shellIntegrationQuality === ShellIntegrationQuality.None || toolTerminal.shellIntegrationQuality === ShellIntegrationQuality.Basic) {
                 toolTerminal.shellIntegrationQuality = commandDetection.hasRichCommandDetection ? ShellIntegrationQuality.Rich : ShellIntegrationQuality.Basic;
             }
         }
@@ -96,27 +112,23 @@ let ToolTerminalCreator = class ToolTerminalCreator {
     _createCopilotTerminal(shellOrProfile, os) {
         const shellPath = isString(shellOrProfile) ? shellOrProfile : shellOrProfile.path;
         const env = {
-            GIT_PAGER: 'cat',
+            GIT_PAGER: "cat"
         };
         const preventShellHistory = this._configurationService.getValue(TerminalChatAgentToolsSettingId.PreventShellHistory) === true;
         if (preventShellHistory) {
-            if (isBash(shellPath, os) ||
-                isZsh(shellPath, os) ||
-                isFish(shellPath, os) ||
-                isPowerShell(shellPath, os)) {
-                env['VSCODE_PREVENT_SHELL_HISTORY'] = '1';
+            if (isBash(shellPath, os) || isZsh(shellPath, os) || isFish(shellPath, os) || isPowerShell(shellPath, os)) {
+                env["VSCODE_PREVENT_SHELL_HISTORY"] = "1";
             }
         }
         const config = {
             icon: ThemeIcon.fromId(Codicon.chatSparkle.id),
             hideFromUser: true,
             forcePersist: true,
-            env,
+            env
         };
         if (isString(shellOrProfile)) {
             config.executable = shellOrProfile;
-        }
-        else {
+        } else {
             config.executable = shellOrProfile.path;
             config.args = shellOrProfile.args;
             config.icon = shellOrProfile.icon ?? config.icon;
@@ -126,60 +138,70 @@ let ToolTerminalCreator = class ToolTerminalCreator {
                 ...shellOrProfile.env
             };
         }
-        return this._terminalService.createTerminal({ config });
+        return this._terminalService.createTerminal({
+            config
+        });
     }
     _waitForShellIntegration(instance, timeoutMs) {
         const store = ( new DisposableStore());
         const result = ( new DeferredPromise());
         const siNoneTimer = store.add(( new MutableDisposable()));
         siNoneTimer.value = disposableTimeout(() => {
-            this._logService.info(`ToolTerminalCreator#_waitForShellIntegration: Timed out ${timeoutMs}ms, using no SI`);
+            this._logService.info(
+                `ToolTerminalCreator#_waitForShellIntegration: Timed out ${timeoutMs}ms, using no SI`
+            );
             result.complete(ShellIntegrationQuality.None);
         }, timeoutMs);
         if (instance.capabilities.get(TerminalCapability.CommandDetection)?.hasRichCommandDetection) {
             siNoneTimer.clear();
-            this._logService.info(`ToolTerminalCreator#_waitForShellIntegration: Rich SI available immediately`);
+            this._logService.info(
+                `ToolTerminalCreator#_waitForShellIntegration: Rich SI available immediately`
+            );
             result.complete(ShellIntegrationQuality.Rich);
-        }
-        else {
-            const onSetRichCommandDetection = store.add(this._terminalService.createOnInstanceCapabilityEvent(TerminalCapability.CommandDetection, e => e.onSetRichCommandDetection));
-            store.add(onSetRichCommandDetection.event((e) => {
+        } else {
+            const onSetRichCommandDetection = store.add(
+                this._terminalService.createOnInstanceCapabilityEvent(TerminalCapability.CommandDetection, e => e.onSetRichCommandDetection)
+            );
+            store.add(onSetRichCommandDetection.event(e => {
                 if (e.instance !== instance) {
                     return;
                 }
                 siNoneTimer.clear();
-                this._logService.info(`ToolTerminalCreator#_waitForShellIntegration: Rich SI available eventually`);
+                this._logService.info(
+                    `ToolTerminalCreator#_waitForShellIntegration: Rich SI available eventually`
+                );
                 result.complete(ShellIntegrationQuality.Rich);
             }));
             const commandDetection = instance.capabilities.get(TerminalCapability.CommandDetection);
             if (commandDetection) {
                 siNoneTimer.clear();
                 store.add(disposableTimeout(() => {
-                    this._logService.info(`ToolTerminalCreator#_waitForShellIntegration: Timed out 200ms, using basic SI`);
+                    this._logService.info(
+                        `ToolTerminalCreator#_waitForShellIntegration: Timed out 200ms, using basic SI`
+                    );
                     result.complete(ShellIntegrationQuality.Basic);
                 }, 200));
-            }
-            else {
+            } else {
                 store.add(instance.capabilities.onDidAddCommandDetectionCapability(e => {
                     siNoneTimer.clear();
                     store.add(disposableTimeout(() => {
-                        this._logService.info(`ToolTerminalCreator#_waitForShellIntegration: Timed out 200ms, using basic SI (via listener)`);
+                        this._logService.info(
+                            `ToolTerminalCreator#_waitForShellIntegration: Timed out 200ms, using basic SI (via listener)`
+                        );
                         result.complete(ShellIntegrationQuality.Basic);
                     }, 200));
                 }));
             }
         }
         result.p.finally(() => {
-            this._logService.info(`ToolTerminalCreator#_waitForShellIntegration: Promise complete, disposing store`);
+            this._logService.info(
+                `ToolTerminalCreator#_waitForShellIntegration: Promise complete, disposing store`
+            );
             store.dispose();
         });
         return result.p;
     }
 };
-ToolTerminalCreator = ToolTerminalCreator_1 = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, ITerminalLogService)),
-    ( __param(2, ITerminalService))
-], ToolTerminalCreator));
+ToolTerminalCreator = ToolTerminalCreator_1 = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, ITerminalLogService)), ( __param(2, ITerminalService))], ToolTerminalCreator));
 
 export { ShellIntegrationQuality, ToolTerminalCreator };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/awaitTerminalTool.d.ts

@@ -0,0 +1,12 @@
+import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { type CountTokensCallback, type IPreparedToolInvocation, type IToolData, type IToolImpl, type IToolInvocation, type IToolInvocationPreparationContext, type IToolResult, type ToolProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+export declare const AwaitTerminalToolData: IToolData;
+export interface IAwaitTerminalInputParams {
+    id: string;
+    timeout: number;
+}
+export declare class AwaitTerminalTool extends Disposable implements IToolImpl {
+    prepareToolInvocation(_context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+    invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
+}