@codingame/monaco-vscode-chat-service-override 19.1.4 → 20.0.0

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

@@ -0,0 +1,603 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { OS, OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { count } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { TerminalCapability } from '@codingame/monaco-vscode-a9da9abe-278d-5ce6-9418-99c7c07c5c37-common/vscode/vs/platform/terminal/common/capabilities/capabilities';
+import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { IRemoteAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
+import { ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
+import { ITerminalProfileResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal.service';
+import { getRecommendedToolsOverRunInTerminal } from './alternativeRecommendation.js';
+import { pollForOutputAndIdle, racePollingOrPrompt, promptForMorePolling, getOutput } from './bufferOutputPolling.js';
+import { CommandLineAutoApprover } from './commandLineAutoApprover.js';
+import { BasicExecuteStrategy } from './executeStrategy/basicExecuteStrategy.js';
+import { NoneExecuteStrategy } from './executeStrategy/noneExecuteStrategy.js';
+import { RichExecuteStrategy } from './executeStrategy/richExecuteStrategy.js';
+import { isPowerShell } from './runInTerminalHelpers.js';
+import { splitCommandLineIntoSubCommands, extractInlineSubCommands } from './subCommands.js';
+import { ShellIntegrationQuality, ToolTerminalCreator } from './toolTerminalCreator.js';
+
+var RunInTerminalTool_1;
+const TERMINAL_SESSION_STORAGE_KEY = 'chat.terminalSessions';
+const RunInTerminalToolData = {
+    id: 'run_in_terminal',
+    toolReferenceName: 'runInTerminal',
+    displayName: ( localize(11261, 'Run in Terminal')),
+    modelDescription: [
+        'This tool allows you to execute shell commands in a persistent terminal session, preserving environment variables, working directory, and other context across multiple commands.',
+        '',
+        'Command Execution:',
+        '- Supports multi-line commands',
+        '',
+        'Directory Management:',
+        '- Must use absolute paths to avoid navigation issues.',
+        '',
+        'Program Execution:',
+        '- Supports Python, Node.js, and other executables.',
+        '- Install dependencies via pip, npm, etc.',
+        '',
+        'Background Processes:',
+        '- For long-running tasks (e.g., servers), set isBackground=true.',
+        '- Returns a terminal ID for checking status and runtime later.',
+        '',
+        'Output Management:',
+        '- Output is automatically truncated if longer than 60KB to prevent context overflow',
+        '- Use filters like \'head\', \'tail\', \'grep\' to limit output size',
+        '- For pager commands, disable paging: use \'git --no-pager\' or add \'| cat\'',
+        '',
+        'Best Practices:',
+        '- Be specific with commands to avoid excessive output',
+        '- Use targeted queries instead of broad scans',
+        '- Consider using \'wc -l\' to count before listing many items'
+    ].join('\n'),
+    userDescription: ( localize(11262, 'Tool for running commands in the terminal')),
+    source: ToolDataSource.Internal,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            command: {
+                type: 'string',
+                description: 'The command to run in the terminal.'
+            },
+            explanation: {
+                type: 'string',
+                description: 'A one-sentence description of what the command does. This will be shown to the user before the command is run.'
+            },
+            isBackground: {
+                type: 'boolean',
+                description: 'Whether the command starts a background process. If true, the command will run in the background and you will not see the output. If false, the tool call will block on the command finishing, and then you will get the output. Examples of background processes: building in watch mode, starting a server. You can check the output of a background process later on by using get_terminal_output.'
+            },
+        },
+        required: [
+            'command',
+            'explanation',
+            'isBackground',
+        ]
+    }
+};
+const telemetryIgnoredSequences = [
+    '\x1b[I',
+    '\x1b[O',
+];
+let RunInTerminalTool = class RunInTerminalTool extends Disposable {
+    static { RunInTerminalTool_1 = this; }
+    static { this._backgroundExecutions = ( new Map()); }
+    static getBackgroundOutput(id) {
+        const backgroundExecution = RunInTerminalTool_1._backgroundExecutions.get(id);
+        if (!backgroundExecution) {
+            throw ( new Error('Invalid terminal ID'));
+        }
+        return backgroundExecution.getOutput();
+    }
+    constructor(_instantiationService, _languageModelToolsService, _storageService, _telemetryService, _logService, _terminalProfileResolverService, _terminalService, _remoteAgentService, _chatService, _workspaceContextService, _languageModelsService) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._languageModelToolsService = _languageModelToolsService;
+        this._storageService = _storageService;
+        this._telemetryService = _telemetryService;
+        this._logService = _logService;
+        this._terminalProfileResolverService = _terminalProfileResolverService;
+        this._terminalService = _terminalService;
+        this._remoteAgentService = _remoteAgentService;
+        this._chatService = _chatService;
+        this._workspaceContextService = _workspaceContextService;
+        this._languageModelsService = _languageModelsService;
+        this._sessionTerminalAssociations = ( new Map());
+        this._commandLineAutoApprover = this._register(_instantiationService.createInstance(CommandLineAutoApprover));
+        this._osBackend = this._remoteAgentService.getEnvironment().then(remoteEnv => remoteEnv?.os ?? OS);
+        this._restoreTerminalAssociations();
+        this._register(this._terminalService.onDidDisposeInstance(e => {
+            for (const [sessionId, toolTerminal] of this._sessionTerminalAssociations.entries()) {
+                if (e === toolTerminal.instance) {
+                    this._sessionTerminalAssociations.delete(sessionId);
+                }
+            }
+        }));
+        this._register(this._chatService.onDidDisposeSession(e => {
+            this._cleanupSessionTerminals(e.sessionId);
+        }));
+    }
+    async prepareToolInvocation(context, token) {
+        const args = context.parameters;
+        this._alternativeRecommendation = getRecommendedToolsOverRunInTerminal(args.command, this._languageModelToolsService);
+        const presentation = this._alternativeRecommendation ? 'hidden' : undefined;
+        const os = await this._osBackend;
+        const shell = await this._terminalProfileResolverService.getDefaultShell({
+            os,
+            remoteAuthority: this._remoteAgentService.getConnection()?.remoteAuthority
+        });
+        const language = os === OperatingSystem.Windows ? 'pwsh' : 'sh';
+        const instance = context.chatSessionId ? this._sessionTerminalAssociations.get(context.chatSessionId)?.instance : undefined;
+        let toolEditedCommand = await this._rewriteCommandIfNeeded(args, instance, shell);
+        if (toolEditedCommand === args.command) {
+            toolEditedCommand = undefined;
+        }
+        let confirmationMessages;
+        if (this._alternativeRecommendation) {
+            confirmationMessages = undefined;
+        }
+        else {
+            const actualCommand = toolEditedCommand ?? args.command;
+            const subCommands = splitCommandLineIntoSubCommands(actualCommand, shell, os);
+            const inlineSubCommands = ( subCommands.map(e => Array.from(extractInlineSubCommands(e, shell, os)))).flat();
+            const allSubCommands = [...subCommands, ...inlineSubCommands];
+            const subCommandResults = ( allSubCommands.map(e => this._commandLineAutoApprover.isCommandAutoApproved(e, shell, os)));
+            const commandLineResult = this._commandLineAutoApprover.isCommandLineAutoApproved(actualCommand);
+            const autoApproveReasons = [
+                ...( subCommandResults.map(e => e.reason)),
+                commandLineResult.reason,
+            ];
+            let isAutoApproved = false;
+            if (( subCommandResults.some(e => e.result === 'denied'))) {
+                this._logService.info('autoApprove: Sub-command DENIED auto approval');
+            }
+            else if (commandLineResult.result === 'denied') {
+                this._logService.info('autoApprove: Command line DENIED auto approval');
+            }
+            else {
+                if (subCommandResults.every(e => e.result === 'approved')) {
+                    this._logService.info('autoApprove: All sub-commands auto-approved');
+                    isAutoApproved = true;
+                }
+                else {
+                    this._logService.info('autoApprove: All sub-commands NOT auto-approved');
+                    if (commandLineResult.result === 'approved') {
+                        this._logService.info('autoApprove: Command line auto-approved');
+                        isAutoApproved = true;
+                    }
+                    else {
+                        this._logService.info('autoApprove: Command line NOT auto-approved');
+                    }
+                }
+            }
+            for (const reason of autoApproveReasons) {
+                this._logService.info(`- ${reason}`);
+            }
+            confirmationMessages = isAutoApproved ? undefined : {
+                title: args.isBackground
+                    ? ( localize(11263, "Run command in background terminal"))
+                    : ( localize(11264, "Run command in terminal")),
+                message: ( new MarkdownString(args.explanation)),
+            };
+        }
+        return {
+            confirmationMessages,
+            presentation,
+            toolSpecificData: {
+                kind: 'terminal',
+                commandLine: {
+                    original: args.command,
+                    toolEdited: toolEditedCommand
+                },
+                language,
+            }
+        };
+    }
+    async invoke(invocation, _countTokens, _progress, token) {
+        if (this._alternativeRecommendation) {
+            return this._alternativeRecommendation;
+        }
+        const args = invocation.parameters;
+        this._logService.debug(`RunInTerminalTool: Invoking with options ${JSON.stringify(args)}`);
+        const toolSpecificData = invocation.toolSpecificData;
+        if (!toolSpecificData) {
+            throw ( new Error('toolSpecificData must be provided for this tool'));
+        }
+        let toolResultMessage;
+        const chatSessionId = invocation.context?.sessionId ?? 'no-chat-session';
+        const command = toolSpecificData.commandLine.userEdited ?? toolSpecificData.commandLine.toolEdited ?? toolSpecificData.commandLine.original;
+        const didUserEditCommand = (toolSpecificData.commandLine.userEdited !== undefined &&
+            toolSpecificData.commandLine.userEdited !== toolSpecificData.commandLine.original);
+        const didToolEditCommand = (!didUserEditCommand &&
+            toolSpecificData.commandLine.toolEdited !== undefined &&
+            toolSpecificData.commandLine.toolEdited !== toolSpecificData.commandLine.original);
+        if (token.isCancellationRequested) {
+            throw ( new CancellationError());
+        }
+        let error;
+        const isNewSession = !args.isBackground && !( this._sessionTerminalAssociations.has(chatSessionId));
+        const timingStart = Date.now();
+        const termId = generateUuid();
+        const store = ( new DisposableStore());
+        this._logService.debug(`RunInTerminalTool: Creating ${args.isBackground ? 'background' : 'foreground'} terminal. termId=${termId}, chatSessionId=${chatSessionId}`);
+        const toolTerminal = await (args.isBackground
+            ? this._initBackgroundTerminal(chatSessionId, termId, token)
+            : this._initForegroundTerminal(chatSessionId, termId, token));
+        this._terminalService.setActiveInstance(toolTerminal.instance);
+        this._terminalService.revealTerminal(toolTerminal.instance, true);
+        const timingConnectMs = Date.now() - timingStart;
+        const xterm = await toolTerminal.instance.xtermReadyPromise;
+        if (!xterm) {
+            throw ( new Error('Instance was disposed before xterm.js was ready'));
+        }
+        let inputUserChars = 0;
+        let inputUserSigint = false;
+        store.add(xterm.raw.onData(data => {
+            if (!telemetryIgnoredSequences.includes(data)) {
+                inputUserChars += data.length;
+            }
+            inputUserSigint ||= data === '\x03';
+        }));
+        if (args.isBackground) {
+            let outputAndIdle = undefined;
+            try {
+                this._logService.debug(`RunInTerminalTool: Starting background execution \`${command}\``);
+                const execution = ( new BackgroundTerminalExecution(toolTerminal.instance, xterm, command));
+                RunInTerminalTool_1._backgroundExecutions.set(termId, execution);
+                outputAndIdle = await pollForOutputAndIdle(execution, false, token, this._languageModelsService);
+                if (token.isCancellationRequested) {
+                    throw ( new CancellationError());
+                }
+                if (!outputAndIdle.terminalExecutionIdleBeforeTimeout) {
+                    outputAndIdle = await racePollingOrPrompt(() => pollForOutputAndIdle(execution, true, token, this._languageModelsService), () => promptForMorePolling(command, token, invocation.context, this._chatService), outputAndIdle, token, this._languageModelsService, execution);
+                    if (token.isCancellationRequested) {
+                        throw ( new CancellationError());
+                    }
+                }
+                let resultText = (didUserEditCommand
+                    ? `Note: The user manually edited the command to \`${command}\`, and that command is now running in terminal with ID=${termId}`
+                    : didToolEditCommand
+                        ? `Note: The tool simplified the command to \`${command}\`, and that command is now running in terminal with ID=${termId}`
+                        : `Command is running in terminal with ID=${termId}`);
+                if (outputAndIdle && outputAndIdle.modelOutputEvalResponse) {
+                    resultText += `\n\ The command became idle with output:\n${outputAndIdle.modelOutputEvalResponse}`;
+                }
+                else if (outputAndIdle) {
+                    resultText += `\n\ The command is still running, with output:\n${outputAndIdle.output}`;
+                }
+                return {
+                    content: [{
+                            kind: 'text',
+                            value: resultText,
+                        }]
+                };
+            }
+            catch (e) {
+                if (termId) {
+                    RunInTerminalTool_1._backgroundExecutions.get(termId)?.dispose();
+                    RunInTerminalTool_1._backgroundExecutions.delete(termId);
+                }
+                error = e instanceof CancellationError ? 'canceled' : 'unexpectedException';
+                throw e;
+            }
+            finally {
+                store.dispose();
+                this._logService.debug(`RunInTerminalTool: Finished polling \`${outputAndIdle?.output.length}\` lines of output in \`${outputAndIdle?.pollDurationMs}\``);
+                const timingExecuteMs = Date.now() - timingStart;
+                this._sendTelemetry(toolTerminal.instance, {
+                    didUserEditCommand,
+                    didToolEditCommand,
+                    shellIntegrationQuality: toolTerminal.shellIntegrationQuality,
+                    isBackground: true,
+                    error,
+                    exitCode: undefined,
+                    isNewSession: true,
+                    timingExecuteMs,
+                    timingConnectMs,
+                    terminalExecutionIdleBeforeTimeout: outputAndIdle?.terminalExecutionIdleBeforeTimeout,
+                    outputLineCount: outputAndIdle?.output ? count(outputAndIdle.output, '\n') : 0,
+                    pollDurationMs: outputAndIdle?.pollDurationMs,
+                    inputUserChars,
+                    inputUserSigint,
+                });
+            }
+        }
+        else {
+            let terminalResult = '';
+            let outputLineCount = -1;
+            let exitCode;
+            try {
+                let strategy;
+                const commandDetection = toolTerminal.instance.capabilities.get(TerminalCapability.CommandDetection);
+                switch (toolTerminal.shellIntegrationQuality) {
+                    case ShellIntegrationQuality.None: {
+                        strategy = this._instantiationService.createInstance(NoneExecuteStrategy, toolTerminal.instance);
+                        toolResultMessage = ( new MarkdownString(
+                            'Enable [shell integration](https://code.visualstudio.com/docs/terminal/shell-integration) to improve command detection'
+                        ));
+                        break;
+                    }
+                    case ShellIntegrationQuality.Basic: {
+                        strategy = this._instantiationService.createInstance(BasicExecuteStrategy, toolTerminal.instance, commandDetection);
+                        break;
+                    }
+                    case ShellIntegrationQuality.Rich: {
+                        strategy = this._instantiationService.createInstance(RichExecuteStrategy, toolTerminal.instance, commandDetection);
+                        break;
+                    }
+                }
+                this._logService.debug(`RunInTerminalTool: Using \`${strategy.type}\` execute strategy for command \`${command}\``);
+                const executeResult = await strategy.execute(command, token);
+                if (token.isCancellationRequested) {
+                    throw ( new CancellationError());
+                }
+                this._logService.debug(`RunInTerminalTool: Finished \`${strategy.type}\` execute strategy with exitCode \`${executeResult.exitCode}\`, result.length \`${executeResult.output?.length}\`, error \`${executeResult.error}\``);
+                outputLineCount = executeResult.output === undefined ? 0 : count(executeResult.output.trim(), '\n') + 1;
+                exitCode = executeResult.exitCode;
+                error = executeResult.error;
+                const resultArr = [];
+                if (executeResult.output !== undefined) {
+                    resultArr.push(executeResult.output);
+                }
+                if (executeResult.additionalInformation) {
+                    resultArr.push(executeResult.additionalInformation);
+                }
+                terminalResult = resultArr.join('\n\n');
+            }
+            catch (e) {
+                this._logService.debug(`RunInTerminalTool: Threw exception`);
+                toolTerminal.instance.dispose();
+                error = e instanceof CancellationError ? 'canceled' : 'unexpectedException';
+                throw e;
+            }
+            finally {
+                store.dispose();
+                const timingExecuteMs = Date.now() - timingStart;
+                this._sendTelemetry(toolTerminal.instance, {
+                    didUserEditCommand,
+                    didToolEditCommand,
+                    isBackground: false,
+                    shellIntegrationQuality: toolTerminal.shellIntegrationQuality,
+                    error,
+                    isNewSession,
+                    outputLineCount,
+                    exitCode,
+                    timingExecuteMs,
+                    timingConnectMs,
+                    inputUserChars,
+                    inputUserSigint,
+                });
+            }
+            const resultText = [];
+            if (didUserEditCommand) {
+                resultText.push(`Note: The user manually edited the command to \`${command}\`, and this is the output of running that command instead:\n`);
+            }
+            else if (didToolEditCommand) {
+                resultText.push(`Note: The tool simplified the command to \`${command}\`, and this is the output of running that command instead:\n`);
+            }
+            resultText.push(terminalResult);
+            return {
+                toolResultMessage,
+                content: [{
+                        kind: 'text',
+                        value: resultText.join(''),
+                    }]
+            };
+        }
+    }
+    async _initBackgroundTerminal(chatSessionId, termId, token) {
+        this._logService.debug(`RunInTerminalTool: Creating background terminal with ID=${termId}`);
+        const toolTerminal = await this._instantiationService.createInstance(ToolTerminalCreator).createTerminal(token);
+        this._sessionTerminalAssociations.set(chatSessionId, toolTerminal);
+        if (token.isCancellationRequested) {
+            toolTerminal.instance.dispose();
+            throw ( new CancellationError());
+        }
+        await this._setupProcessIdAssociation(toolTerminal, chatSessionId, termId, true);
+        return toolTerminal;
+    }
+    async _initForegroundTerminal(chatSessionId, termId, token) {
+        const cachedTerminal = this._sessionTerminalAssociations.get(chatSessionId);
+        if (cachedTerminal) {
+            this._logService.debug(`RunInTerminalTool: Using cached foreground terminal with session ID \`${chatSessionId}\``);
+            return cachedTerminal;
+        }
+        const toolTerminal = await this._instantiationService.createInstance(ToolTerminalCreator).createTerminal(token);
+        this._sessionTerminalAssociations.set(chatSessionId, toolTerminal);
+        if (token.isCancellationRequested) {
+            toolTerminal.instance.dispose();
+            throw ( new CancellationError());
+        }
+        await this._setupProcessIdAssociation(toolTerminal, chatSessionId, termId, false);
+        return toolTerminal;
+    }
+    async _rewriteCommandIfNeeded(args, instance, shell) {
+        const commandLine = args.command;
+        const os = await this._osBackend;
+        const isPwsh = isPowerShell(shell, os);
+        const cdPrefixMatch = commandLine.match(isPwsh
+            ? /^(?:cd(?: \/d)?|Set-Location(?: -Path)?) (?<dir>[^\s]+) ?(?:&&|;)\s+(?<suffix>.+)$/i
+            : /^cd (?<dir>[^\s]+) &&\s+(?<suffix>.+)$/);
+        const cdDir = cdPrefixMatch?.groups?.dir;
+        const cdSuffix = cdPrefixMatch?.groups?.suffix;
+        if (cdDir && cdSuffix) {
+            let cwd;
+            if (instance) {
+                cwd = await instance.getCwdResource();
+            }
+            if (!cwd) {
+                const workspaceFolders = this._workspaceContextService.getWorkspace().folders;
+                if (workspaceFolders.length === 1) {
+                    cwd = workspaceFolders[0].uri;
+                }
+            }
+            if (cwd) {
+                let cdDirPath = cdDir;
+                if (cdDirPath.startsWith('"') && cdDirPath.endsWith('"')) {
+                    cdDirPath = cdDirPath.slice(1, -1);
+                }
+                cdDirPath = cdDirPath.replace(/(?:[\\\/])$/, '');
+                let cwdFsPath = cwd.fsPath.replace(/(?:[\\\/])$/, '');
+                if (os === OperatingSystem.Windows) {
+                    cdDirPath = cdDirPath.toLowerCase();
+                    cwdFsPath = cwdFsPath.toLowerCase();
+                }
+                if (cdDirPath === cwdFsPath) {
+                    return cdSuffix;
+                }
+            }
+        }
+        return commandLine;
+    }
+    _restoreTerminalAssociations() {
+        const storedAssociations = this._storageService.get(TERMINAL_SESSION_STORAGE_KEY, StorageScope.WORKSPACE, '{}');
+        try {
+            const associations = JSON.parse(storedAssociations);
+            for (const instance of this._terminalService.instances) {
+                if (instance.processId) {
+                    const association = associations[instance.processId];
+                    if (association) {
+                        this._logService.debug(`RunInTerminalTool: Restored terminal association for PID ${instance.processId}, session ${association.sessionId}`);
+                        const toolTerminal = {
+                            instance,
+                            shellIntegrationQuality: association.shellIntegrationQuality
+                        };
+                        this._sessionTerminalAssociations.set(association.sessionId, toolTerminal);
+                        this._register(instance.onDisposed(() => {
+                            this._removeProcessIdAssociation(instance.processId);
+                        }));
+                    }
+                }
+            }
+        }
+        catch (error) {
+            this._logService.debug(`RunInTerminalTool: Failed to restore terminal associations: ${error}`);
+        }
+    }
+    async _setupProcessIdAssociation(toolTerminal, chatSessionId, termId, isBackground) {
+        await this._associateProcessIdWithSession(toolTerminal.instance, chatSessionId, termId, toolTerminal.shellIntegrationQuality, isBackground);
+        this._register(toolTerminal.instance.onDisposed(() => {
+            if (toolTerminal.instance.processId) {
+                this._removeProcessIdAssociation(toolTerminal.instance.processId);
+            }
+        }));
+    }
+    async _associateProcessIdWithSession(terminal, sessionId, id, shellIntegrationQuality, isBackground) {
+        try {
+            const pid = await Promise.race([
+                terminal.processReady.then(() => terminal.processId),
+                timeout(5000).then(() => { throw ( new Error('Timeout')); })
+            ]);
+            if (typeof pid === 'number') {
+                const storedAssociations = this._storageService.get(TERMINAL_SESSION_STORAGE_KEY, StorageScope.WORKSPACE, '{}');
+                const associations = JSON.parse(storedAssociations);
+                const existingAssociation = associations[pid] || {};
+                associations[pid] = {
+                    ...existingAssociation,
+                    sessionId,
+                    shellIntegrationQuality,
+                    id,
+                    isBackground
+                };
+                this._storageService.store(TERMINAL_SESSION_STORAGE_KEY, JSON.stringify(associations), StorageScope.WORKSPACE, StorageTarget.USER);
+                this._logService.debug(`RunInTerminalTool: Associated terminal PID ${pid} with session ${sessionId}`);
+            }
+        }
+        catch (error) {
+            this._logService.debug(`RunInTerminalTool: Failed to associate terminal with session: ${error}`);
+        }
+    }
+    async _removeProcessIdAssociation(pid) {
+        try {
+            const storedAssociations = this._storageService.get(TERMINAL_SESSION_STORAGE_KEY, StorageScope.WORKSPACE, '{}');
+            const associations = JSON.parse(storedAssociations);
+            if (associations[pid]) {
+                delete associations[pid];
+                this._storageService.store(TERMINAL_SESSION_STORAGE_KEY, JSON.stringify(associations), StorageScope.WORKSPACE, StorageTarget.USER);
+                this._logService.debug(`RunInTerminalTool: Removed terminal association for PID ${pid}`);
+            }
+        }
+        catch (error) {
+            this._logService.debug(`RunInTerminalTool: Failed to remove terminal association: ${error}`);
+        }
+    }
+    _cleanupSessionTerminals(sessionId) {
+        const toolTerminal = this._sessionTerminalAssociations.get(sessionId);
+        if (toolTerminal) {
+            this._logService.debug(`RunInTerminalTool: Cleaning up terminal for disposed chat session ${sessionId}`);
+            this._sessionTerminalAssociations.delete(sessionId);
+            toolTerminal.instance.dispose();
+            const terminalToRemove = [];
+            for (const [termId, execution] of RunInTerminalTool_1._backgroundExecutions.entries()) {
+                if (execution.instance === toolTerminal.instance) {
+                    execution.dispose();
+                    terminalToRemove.push(termId);
+                }
+            }
+            for (const termId of terminalToRemove) {
+                RunInTerminalTool_1._backgroundExecutions.delete(termId);
+            }
+        }
+    }
+    _sendTelemetry(instance, state) {
+        this._telemetryService.publicLog2('toolUse.runInTerminal', {
+            terminalSessionId: instance.sessionId,
+            result: state.error ?? 'success',
+            strategy: state.shellIntegrationQuality === ShellIntegrationQuality.Rich ? 2 : state.shellIntegrationQuality === ShellIntegrationQuality.Basic ? 1 : 0,
+            userEditedCommand: state.didUserEditCommand ? 1 : 0,
+            toolEditedCommand: state.didToolEditCommand ? 1 : 0,
+            isBackground: state.isBackground ? 1 : 0,
+            isNewSession: state.isNewSession ? 1 : 0,
+            outputLineCount: state.outputLineCount,
+            nonZeroExitCode: state.exitCode === undefined ? -1 : state.exitCode === 0 ? 0 : 1,
+            timingConnectMs: state.timingConnectMs,
+            pollDurationMs: state.pollDurationMs ?? 0,
+            terminalExecutionIdleBeforeTimeout: state.terminalExecutionIdleBeforeTimeout ?? false,
+            inputUserChars: state.inputUserChars,
+            inputUserSigint: state.inputUserSigint,
+        });
+    }
+};
+RunInTerminalTool = RunInTerminalTool_1 = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, ILanguageModelToolsService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, ITelemetryService)),
+    ( __param(4, ITerminalLogService)),
+    ( __param(5, ITerminalProfileResolverService)),
+    ( __param(6, ITerminalService)),
+    ( __param(7, IRemoteAgentService)),
+    ( __param(8, IChatService)),
+    ( __param(9, IWorkspaceContextService)),
+    ( __param(10, ILanguageModelsService))
+], RunInTerminalTool));
+class BackgroundTerminalExecution extends Disposable {
+    constructor(instance, _xterm, _commandLine) {
+        super();
+        this.instance = instance;
+        this._xterm = _xterm;
+        this._commandLine = _commandLine;
+        this._startMarker = this._register(this._xterm.raw.registerMarker());
+        this.instance.runCommand(this._commandLine, true);
+    }
+    getOutput() {
+        return getOutput(this.instance, this._startMarker);
+    }
+}
+
+export { RunInTerminalTool, RunInTerminalToolData };

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

@@ -0,0 +1,3 @@
+import type { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+export declare function splitCommandLineIntoSubCommands(commandLine: string, envShell: string, envOS: OperatingSystem): string[];
+export declare function extractInlineSubCommands(commandLine: string, envShell: string, envOS: OperatingSystem): Set<string>;