@codingame/monaco-vscode-chat-service-override 20.4.1 → 21.0.0

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

@@ -1,10 +1,35 @@
 
 import { isPowerShell } from './runInTerminalHelpers.js';
 
+function createNumberRange(start, end) {
+    return Array.from({ length: end - start + 1 }, (_, i) => ( (start + i).toString()));
+}
+function sortByStringLengthDesc(arr) {
+    return [...arr].sort((a, b) => b.length - a.length);
+}
 const shellTypeResetChars = ( new Map([
-    ['sh', ['&>>', '2>>', '>>', '2>', '&>', '||', '&&', '|&', '<<', '&', ';', '{', '>', '<', '|']],
-    ['zsh', ['<<<', '2>>', '&>>', '>>', '2>', '&>', '<(', '<>', '||', '&&', '|&', '&', ';', '{', '<<', '<(', '>', '<', '|']],
-    ['pwsh', ['*>>', '2>>', '>>', '2>', '&&', '*>', '>', '<', '|', ';', '!', '&']],
+    ['sh', sortByStringLengthDesc([
+            ...( createNumberRange(1, 9).concat('').map(n => `${n}<<<`)),
+            ...createNumberRange(1, 9).concat('').flatMap(n => ( createNumberRange(1, 9).map(m => `${n}>&${m}`))),
+            ...( createNumberRange(1, 9).concat('').map(n => `${n}<>`)),
+            ...( createNumberRange(1, 9).concat('&', '').map(n => `${n}>>`)),
+            ...( createNumberRange(1, 9).concat('&', '').map(n => `${n}>`)),
+            '0<', '||', '&&', '|&', '<<', '&', ';', '{', '>', '<', '|'
+        ])],
+    ['zsh', sortByStringLengthDesc([
+            ...( createNumberRange(1, 9).concat('').map(n => `${n}<<<`)),
+            ...createNumberRange(1, 9).concat('').flatMap(n => ( createNumberRange(1, 9).map(m => `${n}>&${m}`))),
+            ...( createNumberRange(1, 9).concat('').map(n => `${n}<>`)),
+            ...( createNumberRange(1, 9).concat('&', '').map(n => `${n}>>`)),
+            ...( createNumberRange(1, 9).concat('&', '').map(n => `${n}>`)),
+            '<(', '||', '>|', '>!', '&&', '|&', '&', ';', '{', '<(', '<', '|'
+        ])],
+    ['pwsh', sortByStringLengthDesc([
+            ...createNumberRange(1, 6).concat('*', '').flatMap(n => ( createNumberRange(1, 6).map(m => `${n}>&${m}`))),
+            ...( createNumberRange(1, 6).concat('*', '').map(n => `${n}>>`)),
+            ...( createNumberRange(1, 6).concat('*', '').map(n => `${n}>`)),
+            '&&', '<', '|', ';', '!', '&'
+        ])],
 ]));
 function splitCommandLineIntoSubCommands(commandLine, envShell, envOS) {
     let shellType;
@@ -35,79 +60,7 @@ function splitCommandLineIntoSubCommands(commandLine, envShell, envOS) {
             }
         }
     }
-    return subCommands;
-}
-function extractInlineSubCommands(commandLine, envShell, envOS) {
-    const inlineCommands = [];
-    const shellType = isPowerShell(envShell, envOS) ? 'pwsh' : 'sh';
-    function extractWithPrefix(text, prefix) {
-        const results = [];
-        let i = 0;
-        while (i < text.length) {
-            const startIndex = text.indexOf(prefix, i);
-            if (startIndex === -1) {
-                break;
-            }
-            const contentStart = startIndex + prefix.length;
-            if (contentStart >= text.length || text[contentStart] !== '(') {
-                i = startIndex + 1;
-                continue;
-            }
-            let parenCount = 1;
-            let j = contentStart + 1;
-            while (j < text.length && parenCount > 0) {
-                if (text[j] === '(') {
-                    parenCount++;
-                }
-                else if (text[j] === ')') {
-                    parenCount--;
-                }
-                j++;
-            }
-            if (parenCount === 0) {
-                const innerCommand = text.substring(contentStart + 1, j - 1).trim();
-                if (innerCommand) {
-                    results.push(innerCommand);
-                    results.push(...extractInlineSubCommands(innerCommand, envShell, envOS));
-                }
-            }
-            i = startIndex + 1;
-        }
-        return results;
-    }
-    function extractBackticks(text) {
-        const results = [];
-        let i = 0;
-        while (i < text.length) {
-            const startIndex = text.indexOf('`', i);
-            if (startIndex === -1) {
-                break;
-            }
-            const endIndex = text.indexOf('`', startIndex + 1);
-            if (endIndex === -1) {
-                break;
-            }
-            const innerCommand = text.substring(startIndex + 1, endIndex).trim();
-            if (innerCommand) {
-                results.push(innerCommand);
-                results.push(...extractInlineSubCommands(innerCommand, envShell, envOS));
-            }
-            i = endIndex + 1;
-        }
-        return results;
-    }
-    if (shellType === 'pwsh') {
-        inlineCommands.push(...extractWithPrefix(commandLine, '$'));
-        inlineCommands.push(...extractWithPrefix(commandLine, '@'));
-        inlineCommands.push(...extractWithPrefix(commandLine, '&'));
-    }
-    else {
-        inlineCommands.push(...extractWithPrefix(commandLine, '$'));
-        inlineCommands.push(...extractWithPrefix(commandLine, '<'));
-        inlineCommands.push(...extractWithPrefix(commandLine, '>'));
-        inlineCommands.push(...extractBackticks(commandLine));
-    }
-    return ( new Set(inlineCommands));
+    return subCommands.filter(e => e.length > 0);
 }
 
-export { extractInlineSubCommands, splitCommandLineIntoSubCommands };
+export { splitCommandLineIntoSubCommands };

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

@@ -0,0 +1,62 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { DisposableStore } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IToolInvocationContext, ToolProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService";
+import { Task } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/tasks";
+import { ITaskService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/taskService.service";
+import { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import { IExecution, IPollingResult, OutputMonitorState } from "./tools/monitoring/types.js";
+export declare function getTaskDefinition(id: string): {
+    taskLabel: string;
+    taskType: string;
+};
+export declare function getTaskRepresentation(task: IConfiguredTask | Task): string;
+export declare function getTaskForTool(id: string | undefined, taskDefinition: {
+    taskLabel?: string;
+    taskType?: string;
+}, workspaceFolder: string, configurationService: IConfigurationService, taskService: ITaskService, allowParentTask?: boolean): Promise<Task | undefined>;
+/**
+ * Represents a configured task in the system.
+ *
+ * This interface is used to define tasks that can be executed within the workspace.
+ * It includes optional properties for identifying and describing the task.
+ *
+ * Properties:
+ * - `type`: (optional) The type of the task, which categorizes it (e.g., "build", "test").
+ * - `label`: (optional) A user-facing label for the task, typically used for display purposes.
+ * - `script`: (optional) A script associated with the task, if applicable.
+ * - `command`: (optional) A command associated with the task, if applicable.
+ *
+ */
+export interface IConfiguredTask {
+    label?: string;
+    type?: string;
+    script?: string;
+    command?: string;
+    args?: string[];
+    isBackground?: boolean;
+    problemMatcher?: string[];
+    group?: string;
+}
+export declare function resolveDependencyTasks(parentTask: Task, workspaceFolder: string, configurationService: IConfigurationService, taskService: ITaskService): Promise<Task[] | undefined>;
+/**
+ * Collects output, polling duration, and idle status for all terminals.
+ */
+export declare function collectTerminalResults(terminals: ITerminalInstance[], task: Task, instantiationService: IInstantiationService, invocationContext: IToolInvocationContext, progress: ToolProgress, token: CancellationToken, disposableStore: DisposableStore, isActive?: () => Promise<boolean>, dependencyTasks?: Task[]): Promise<Array<{
+    name: string;
+    output: string;
+    resources?: ILinkLocation[];
+    pollDurationMs: number;
+    state: OutputMonitorState;
+    inputToolManualAcceptCount: number;
+    inputToolManualRejectCount: number;
+    inputToolManualChars: number;
+}>>;
+export declare function taskProblemPollFn(execution: IExecution, token: CancellationToken, taskService: ITaskService): Promise<IPollingResult | undefined>;
+export interface ILinkLocation {
+    uri: URI;
+    range?: Range;
+}

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

@@ -0,0 +1,174 @@
+
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { getOutput } from './outputHelpers.js';
+import { OutputMonitor } from './tools/monitoring/outputMonitor.js';
+import { OutputMonitorState } from './tools/monitoring/types.js';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+
+function getTaskDefinition(id) {
+    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 };
+}
+function getTaskRepresentation(task) {
+    if ('label' in task && task.label) {
+        return task.label;
+    }
+    else if ('script' in task && task.script) {
+        return task.script;
+    }
+    else if ('command' in task && task.command) {
+        return typeof task.command === 'string' ? task.command : task.command.name?.toString() || '';
+    }
+    return '';
+}
+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)) });
+        if (tasksConfig?.tasks) {
+            configTasks = configTasks.concat(tasksConfig.tasks);
+        }
+    }
+    for (const configTask of configTasks) {
+        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))) {
+            task = configTask;
+            break;
+        }
+        else if (!configTask.label && id === `${configTask.type}: ${index}`) {
+            task = configTask;
+            break;
+        }
+        index++;
+    }
+    if (!task) {
+        return;
+    }
+    let tasksForWorkspace;
+    const workspaceFolderPath = URI.file(workspaceFolder).path;
+    for (const [folder, tasks] of workspaceFolderToTaskMap) {
+        if (( URI.parse(folder)).path === workspaceFolderPath) {
+            tasksForWorkspace = tasks;
+            break;
+        }
+    }
+    if (!tasksForWorkspace) {
+        return;
+    }
+    const configuringTasks = tasksForWorkspace.configurations?.byIdentifier;
+    const configuredTask = ( Object.values(configuringTasks ?? {})).find(t => {
+        return t.type === task.type && (t._label === task.label || t._label === `${task.type}: ${getTaskRepresentation(task)}` || t._label === getTaskRepresentation(task));
+    });
+    let resolvedTask;
+    if (configuredTask) {
+        resolvedTask = await taskService.tryResolveTask(configuredTask);
+    }
+    if (!resolvedTask) {
+        const customTasks = tasksForWorkspace.set?.tasks;
+        resolvedTask = customTasks?.find(t => task.label === t._label || task.label === t._label);
+    }
+    return resolvedTask;
+}
+async function resolveDependencyTasks(parentTask, workspaceFolder, configurationService, taskService) {
+    if (!parentTask.configurationProperties?.dependsOn) {
+        return undefined;
+    }
+    const dependencyTasks = await Promise.all(( parentTask.configurationProperties.dependsOn.map(async (dep) => {
+        const depId = typeof dep.task === 'string' ? dep.task : dep.task?._key;
+        if (!depId) {
+            return undefined;
+        }
+        return await getTaskForTool(depId, { taskLabel: depId }, workspaceFolder, configurationService, taskService);
+    })));
+    return dependencyTasks.filter((t) => t !== undefined);
+}
+async function collectTerminalResults(terminals, task, instantiationService, invocationContext, progress, token, disposableStore, isActive, dependencyTasks) {
+    const results = [];
+    if (token.isCancellationRequested) {
+        return results;
+    }
+    for (const instance of terminals) {
+        progress.report({ message: ( new MarkdownString(`Checking output for \`${instance.shellLaunchConfig.name ?? 'unknown'}\``)) });
+        const execution = {
+            getOutput: () => getOutput(instance) ?? '',
+            isActive,
+            task,
+            instance,
+            dependencyTasks,
+            sessionId: invocationContext.sessionId
+        };
+        const outputMonitor = disposableStore.add(instantiationService.createInstance(OutputMonitor, execution, taskProblemPollFn, invocationContext, token, task._label));
+        await Event.toPromise(outputMonitor.onDidFinishCommand);
+        const pollingResult = outputMonitor.pollingResult;
+        results.push({
+            name: instance.shellLaunchConfig.name ?? 'unknown',
+            output: pollingResult?.output ?? '',
+            pollDurationMs: pollingResult?.pollDurationMs ?? 0,
+            resources: pollingResult?.resources,
+            state: pollingResult?.state || OutputMonitorState.Idle,
+            inputToolManualAcceptCount: outputMonitor.outputMonitorTelemetryCounters.inputToolManualAcceptCount ?? 0,
+            inputToolManualRejectCount: outputMonitor.outputMonitorTelemetryCounters.inputToolManualRejectCount ?? 0,
+            inputToolManualChars: outputMonitor.outputMonitorTelemetryCounters.inputToolManualChars ?? 0,
+        });
+    }
+    return results;
+}
+async function taskProblemPollFn(execution, token, taskService) {
+    if (token.isCancellationRequested) {
+        return;
+    }
+    if (execution.task) {
+        const data = taskService.getTaskProblems(execution.instance.instanceId);
+        if (data) {
+            const problemList = [];
+            const resultResources = [];
+            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(
+                            marker.startLineNumber,
+                            marker.startColumn,
+                            marker.endLineNumber,
+                            marker.endColumn
+                        ))
+                            : undefined
+                    });
+                    const label = uri ? uri.path.split('/').pop() ?? ( uri.toString()) : '';
+                    const message = marker.message ?? '';
+                    problemList.push(`Problem: ${message} in ${label} coming from ${owner}`);
+                }
+            }
+            if (problemList.length === 0) {
+                return {
+                    state: OutputMonitorState.Idle,
+                    output: 'The task succeeded with no problems.',
+                };
+            }
+            return {
+                state: OutputMonitorState.Idle,
+                output: problemList.join('\n'),
+                resources: resultResources,
+            };
+        }
+    }
+    throw ( new Error('Polling failed'));
+}
+
+export { collectTerminalResults, getTaskDefinition, getTaskForTool, getTaskRepresentation, resolveDependencyTasks, taskProblemPollFn };

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

@@ -4,29 +4,60 @@ import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codi
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
+import { showChatView } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/browser/chat';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
 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 { GetTerminalOutputTool, GetTerminalOutputToolData } from './getTerminalOutputTool.js';
-import { RunInTerminalTool, RunInTerminalToolData } from './runInTerminalTool.js';
+import { registerActiveInstanceAction, sharedWhenClause } from '@codingame/monaco-vscode-07eaa805-9dea-5ec6-a422-a4f04872424d-common/vscode/vs/workbench/contrib/terminal/browser/terminalActions';
+import { TerminalContextMenuGroup } from '@codingame/monaco-vscode-05a2a821-e4de-5941-b7f9-bbf01c09f229-common/vscode/vs/workbench/contrib/terminal/browser/terminalMenus';
+import { TerminalContextKeys } from '@codingame/monaco-vscode-b6d52a6d-8c8e-51f5-bcd2-1722295e31d9-common/vscode/vs/workbench/contrib/terminal/common/terminalContextKey';
+import { TerminalChatAgentToolsCommandId } from '../common/terminal.chatAgentTools.js';
+import { GetTerminalLastCommandTool, GetTerminalLastCommandToolData } from './tools/getTerminalLastCommandTool.js';
+import { GetTerminalOutputTool, GetTerminalOutputToolData } from './tools/getTerminalOutputTool.js';
+import { GetTerminalSelectionTool, GetTerminalSelectionToolData } from './tools/getTerminalSelectionTool.js';
+import { RunInTerminalTool, RunInTerminalToolData } from './tools/runInTerminalTool.js';
+import { CreateAndRunTaskTool, CreateAndRunTaskToolData } from './tools/task/createAndRunTaskTool.js';
+import { GetTaskOutputTool, GetTaskOutputToolData } from './tools/task/getTaskOutputTool.js';
+import { RunTaskTool, RunTaskToolData } from './tools/task/runTaskTool.js';
 
 let ChatAgentToolsContribution = class ChatAgentToolsContribution extends Disposable {
     static { this.ID = 'terminal.chatAgentTools'; }
     constructor(instantiationService, toolsService) {
         super();
         const runInTerminalTool = instantiationService.createInstance(RunInTerminalTool);
-        this._register(toolsService.registerToolData(RunInTerminalToolData));
-        this._register(toolsService.registerToolImplementation(RunInTerminalToolData.id, runInTerminalTool));
+        this._register(toolsService.registerTool(RunInTerminalToolData, runInTerminalTool));
         const getTerminalOutputTool = instantiationService.createInstance(GetTerminalOutputTool);
-        this._register(toolsService.registerToolData(GetTerminalOutputToolData));
-        this._register(toolsService.registerToolImplementation(GetTerminalOutputToolData.id, getTerminalOutputTool));
-        const toolSet = this._register(toolsService.createToolSet(ToolDataSource.Internal, 'runCommands', 'runCommands', {
+        this._register(toolsService.registerTool(GetTerminalOutputToolData, getTerminalOutputTool));
+        const runCommandsToolSet = this._register(toolsService.createToolSet(ToolDataSource.Internal, 'runCommands', 'runCommands', {
             icon: ThemeIcon.fromId(Codicon.terminal.id),
-            description: ( localize(11304, 'Runs commands in the terminal'))
+            description: ( localize(11430, 'Runs commands in the terminal'))
         }));
-        toolSet.addTool(RunInTerminalToolData);
-        toolSet.addTool(GetTerminalOutputToolData);
+        runCommandsToolSet.addTool(RunInTerminalToolData);
+        runCommandsToolSet.addTool(GetTerminalOutputToolData);
+        const getTerminalSelectionTool = instantiationService.createInstance(GetTerminalSelectionTool);
+        this._register(toolsService.registerTool(GetTerminalSelectionToolData, getTerminalSelectionTool));
+        const getTerminalLastCommandTool = instantiationService.createInstance(GetTerminalLastCommandTool);
+        this._register(toolsService.registerTool(GetTerminalLastCommandToolData, getTerminalLastCommandTool));
+        runCommandsToolSet.addTool(GetTerminalSelectionToolData);
+        runCommandsToolSet.addTool(GetTerminalLastCommandToolData);
+        const runTaskTool = instantiationService.createInstance(RunTaskTool);
+        this._register(toolsService.registerTool(RunTaskToolData, runTaskTool));
+        const getTaskOutputTool = instantiationService.createInstance(GetTaskOutputTool);
+        this._register(toolsService.registerTool(GetTaskOutputToolData, getTaskOutputTool));
+        const createAndRunTaskTool = instantiationService.createInstance(CreateAndRunTaskTool);
+        this._register(toolsService.registerTool(CreateAndRunTaskToolData, createAndRunTaskTool));
+        const runTasksToolSet = this._register(toolsService.createToolSet(ToolDataSource.Internal, 'runTasks', 'runTasks', {
+            description: ( localize(11431, 'Runs tasks and gets their output for your workspace')),
+        }));
+        runTasksToolSet.addTool(RunTaskToolData);
+        runTasksToolSet.addTool(GetTaskOutputToolData);
+        runTasksToolSet.addTool(CreateAndRunTaskToolData);
     }
 };
 ChatAgentToolsContribution = ( __decorate([
@@ -34,3 +65,37 @@ ChatAgentToolsContribution = ( __decorate([
     ( __param(1, ILanguageModelToolsService))
 ], ChatAgentToolsContribution));
 registerWorkbenchContribution2(ChatAgentToolsContribution.ID, ChatAgentToolsContribution, WorkbenchPhase.AfterRestored);
+registerActiveInstanceAction({
+    id: TerminalChatAgentToolsCommandId.ChatAddTerminalSelection,
+    title: ( localize(11432, '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))
+        },
+    ],
+    run: async (activeInstance, _c, accessor) => {
+        const viewsService = accessor.get(IViewsService);
+        const chatWidgetService = accessor.get(IChatWidgetService);
+        const selection = activeInstance.selection;
+        if (!selection) {
+            return;
+        }
+        const chatView = chatWidgetService.lastFocusedWidget || (await showChatView(viewsService));
+        if (!chatView) {
+            return;
+        }
+        chatView.attachmentModel.addContext({
+            id: `terminal-selection-${Date.now()}`,
+            kind: 'generic',
+            name: ( localize(11433, 'Terminal Selection')),
+            fullName: ( localize(11433, 'Terminal Selection')),
+            value: selection,
+            icon: Codicon.terminal
+        });
+        chatView.focusInput();
+    }
+});

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

@@ -1,4 +1,6 @@
 import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { ITerminalLogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service";
 import { type ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
 import { ITerminalService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
 export declare enum ShellIntegrationQuality {
@@ -9,16 +11,27 @@ export declare enum ShellIntegrationQuality {
 export interface IToolTerminal {
     instance: ITerminalInstance;
     shellIntegrationQuality: ShellIntegrationQuality;
+    receivedUserInput?: boolean;
 }
 export declare class ToolTerminalCreator {
+    private readonly _configurationService;
+    private readonly _logService;
     private readonly _terminalService;
     /**
      * The shell preference cached for the lifetime of the window. This allows skipping previous
      * shell approaches that failed in previous runs to save time.
      */
     private static _lastSuccessfulShell;
-    constructor(_terminalService: ITerminalService);
-    createTerminal(token: CancellationToken): Promise<IToolTerminal>;
+    constructor(_configurationService: IConfigurationService, _logService: ITerminalLogService, _terminalService: ITerminalService);
+    createTerminal(shell: string, token: CancellationToken): Promise<IToolTerminal>;
+    /**
+     * Synchronously update shell integration quality based on the terminal instance's current
+     * capabilities. This is a defensive change to avoid no shell integration being sticky
+     * https://github.com/microsoft/vscode/issues/260880
+     *
+     * Only upgrade quality just in case.
+     */
+    refreshShellIntegrationQuality(toolTerminal: IToolTerminal): void;
     private _createCopilotTerminal;
     private _waitForShellIntegration;
 }