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

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/monitoring/outputMonitor.js

@@ -0,0 +1,452 @@
+
+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 { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ExtensionIdentifier } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions';
+import { ChatElicitationRequestPart } from '@codingame/monaco-vscode-dc3fa21d-a483-5b99-a7ab-173235644a34-common/vscode/vs/workbench/contrib/chat/browser/chatElicitationRequestPart';
+import { ChatModel } from '@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatModel';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { ChatMessageRole } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
+import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { ITaskService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/taskService.service';
+import { OutputMonitorState, PollingConsts } from './types.js';
+import { getTextResponseFromStream } from './utils.js';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { isObject, isString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { detectsInputRequiredPattern } from '../../executeStrategy/executeStrategy.js';
+
+let OutputMonitor = class OutputMonitor extends Disposable {
+    get state() { return this._state; }
+    get pollingResult() { return this._pollingResult; }
+    get outputMonitorTelemetryCounters() { return this._outputMonitorTelemetryCounters; }
+    constructor(_execution, _pollFn, invocationContext, token, command, _languageModelsService, _taskService, _chatService, _chatWidgetService) {
+        super();
+        this._execution = _execution;
+        this._pollFn = _pollFn;
+        this._languageModelsService = _languageModelsService;
+        this._taskService = _taskService;
+        this._chatService = _chatService;
+        this._chatWidgetService = _chatWidgetService;
+        this._state = OutputMonitorState.PollingForIdle;
+        this._outputMonitorTelemetryCounters = {
+            inputToolManualAcceptCount: 0,
+            inputToolManualRejectCount: 0,
+            inputToolManualChars: 0
+        };
+        this._onDidFinishCommand = this._register(( new Emitter()));
+        this.onDidFinishCommand = this._onDidFinishCommand.event;
+        timeout(0).then(() => {
+            this._startMonitoring(command, invocationContext, token);
+        });
+    }
+    async _startMonitoring(command, invocationContext, token) {
+        const pollStartTime = Date.now();
+        let modelOutputEvalResponse;
+        let resources;
+        let extended = false;
+        try {
+            while (!token.isCancellationRequested) {
+                switch (this._state) {
+                    case OutputMonitorState.PollingForIdle: {
+                        this._state = await this._waitForIdle(this._execution, extended, token);
+                        continue;
+                    }
+                    case OutputMonitorState.Timeout: {
+                        const shouldContinuePolling = await this._handleTimeoutState(command, invocationContext, extended, token);
+                        if (shouldContinuePolling) {
+                            extended = true;
+                            continue;
+                        }
+                        else {
+                            this._promptPart?.hide();
+                            this._promptPart?.dispose();
+                            this._promptPart = undefined;
+                            break;
+                        }
+                    }
+                    case OutputMonitorState.Cancelled:
+                        break;
+                    case OutputMonitorState.Idle: {
+                        const idleResult = await this._handleIdleState(token);
+                        if (idleResult.shouldContinuePollling) {
+                            continue;
+                        }
+                        else {
+                            resources = idleResult.resources;
+                            modelOutputEvalResponse = idleResult.modelOutputEvalResponse;
+                        }
+                        break;
+                    }
+                }
+                if (this._state === OutputMonitorState.Idle || this._state === OutputMonitorState.Cancelled || this._state === OutputMonitorState.Timeout) {
+                    break;
+                }
+            }
+            if (token.isCancellationRequested) {
+                this._state = OutputMonitorState.Cancelled;
+            }
+        }
+        finally {
+            this._pollingResult = {
+                state: this._state,
+                output: this._execution.getOutput(),
+                modelOutputEvalResponse: token.isCancellationRequested ? 'Cancelled' : modelOutputEvalResponse,
+                pollDurationMs: Date.now() - pollStartTime,
+                resources
+            };
+            this._promptPart?.hide();
+            this._promptPart?.dispose();
+            this._promptPart = undefined;
+            this._onDidFinishCommand.fire();
+        }
+    }
+    async _handleIdleState(token) {
+        const confirmationPrompt = await this._determineUserInputOptions(this._execution, token);
+        const suggestedOption = await this._selectAndHandleOption(confirmationPrompt, token);
+        if (confirmationPrompt?.options.length) {
+            const confirmed = await this._confirmRunInTerminal(suggestedOption ?? confirmationPrompt.options[0], this._execution, confirmationPrompt);
+            if (confirmed) {
+                return { shouldContinuePollling: true };
+            }
+            else {
+                this._execution.instance.focus(true);
+                return { shouldContinuePollling: false };
+            }
+        }
+        const custom = await this._pollFn?.(this._execution, token, this._taskService);
+        const resources = custom?.resources;
+        const modelOutputEvalResponse = await this._assessOutputForErrors(this._execution.getOutput(), token);
+        return { resources, modelOutputEvalResponse, shouldContinuePollling: false };
+    }
+    async _handleTimeoutState(command, invocationContext, extended, token) {
+        let continuePollingPart;
+        if (extended) {
+            this._state = OutputMonitorState.Cancelled;
+            return false;
+        }
+        extended = true;
+        const { promise: p, part } = await this._promptForMorePolling(command, token, invocationContext);
+        let continuePollingDecisionP = p;
+        continuePollingPart = part;
+        const nextPollP = this._waitForIdle(this._execution, extended, token)
+            .catch(() => ({
+            state: OutputMonitorState.Cancelled,
+            output: this._execution.getOutput(),
+            modelOutputEvalResponse: 'Cancelled'
+        }));
+        const race = await Promise.race([
+            continuePollingDecisionP.then(v => ({ kind: 'decision', v })),
+            nextPollP.then(r => ({ kind: 'poll', r }))
+        ]);
+        if (race.kind === 'decision') {
+            try {
+                continuePollingPart?.hide();
+                continuePollingPart?.dispose?.();
+            }
+            catch {  }
+            continuePollingPart = undefined;
+            if (race.v === false) {
+                this._state = OutputMonitorState.Cancelled;
+                return false;
+            }
+            continuePollingDecisionP = undefined;
+            return true;
+        }
+        else {
+            const r = race.r;
+            if (r === OutputMonitorState.Idle || r === OutputMonitorState.Cancelled || r === OutputMonitorState.Timeout) {
+                try {
+                    continuePollingPart?.hide();
+                    continuePollingPart?.dispose?.();
+                }
+                catch {  }
+                continuePollingPart = undefined;
+                continuePollingDecisionP = undefined;
+                return false;
+            }
+            return true;
+        }
+    }
+    async _waitForIdle(execution, extendedPolling, token) {
+        const maxWaitMs = extendedPolling ? PollingConsts.ExtendedPollingMaxDuration : PollingConsts.FirstPollingMaxDuration;
+        const maxInterval = PollingConsts.MaxPollingIntervalDuration;
+        let currentInterval = PollingConsts.MinPollingDuration;
+        let waited = 0;
+        let consecutiveIdleEvents = 0;
+        let hasReceivedData = false;
+        let currentOutput;
+        let onDataDisposable = Disposable.None;
+        try {
+            while (!token.isCancellationRequested && waited < maxWaitMs) {
+                const waitTime = Math.min(currentInterval, maxWaitMs - waited);
+                await timeout(waitTime, token);
+                waited += waitTime;
+                currentInterval = Math.min(currentInterval * 2, maxInterval);
+                if (currentOutput === undefined) {
+                    currentOutput = execution.getOutput();
+                    onDataDisposable = execution.instance.onData((data) => {
+                        hasReceivedData = true;
+                        currentOutput += data;
+                    });
+                }
+                const promptResult = detectsInputRequiredPattern(currentOutput);
+                if (promptResult) {
+                    this._state = OutputMonitorState.Idle;
+                    return this._state;
+                }
+                if (hasReceivedData) {
+                    consecutiveIdleEvents = 0;
+                    hasReceivedData = false;
+                }
+                else {
+                    consecutiveIdleEvents++;
+                }
+                const recentlyIdle = consecutiveIdleEvents >= PollingConsts.MinIdleEvents;
+                const isActive = execution.isActive ? await execution.isActive() : undefined;
+                if (recentlyIdle && isActive === true) {
+                    consecutiveIdleEvents = 0;
+                    continue;
+                }
+                if (recentlyIdle || isActive === false) {
+                    return OutputMonitorState.Idle;
+                }
+            }
+        }
+        finally {
+            onDataDisposable.dispose();
+        }
+        if (token.isCancellationRequested) {
+            return OutputMonitorState.Cancelled;
+        }
+        return OutputMonitorState.Timeout;
+    }
+    async _promptForMorePolling(command, token, context) {
+        if (token.isCancellationRequested || this._state === OutputMonitorState.Cancelled) {
+            return { promise: Promise.resolve(false) };
+        }
+        const chatModel = this._chatService.getSession(context.sessionId);
+        if (chatModel instanceof ChatModel) {
+            const request = chatModel.getRequests().at(-1);
+            if (request) {
+                let part = undefined;
+                const promise = ( new Promise(resolve => {
+                    const thePart = part = this._register(( new ChatElicitationRequestPart(( new MarkdownString(( localize(11443, "Continue waiting for `{0}`?", command)))), ( new MarkdownString(( localize(
+                        11444,
+                        "This will continue to poll for output to determine when the terminal becomes idle for up to 2 minutes."
+                    )))), '', ( localize(11445, 'Yes')), ( localize(11446, 'No')), async () => {
+                        thePart.state = 'accepted';
+                        thePart.hide();
+                        thePart.dispose();
+                        this._promptPart = undefined;
+                        resolve(true);
+                    }, async () => {
+                        thePart.state = 'rejected';
+                        thePart.hide();
+                        this._state = OutputMonitorState.Cancelled;
+                        this._promptPart = undefined;
+                        resolve(false);
+                    })));
+                    chatModel.acceptResponseProgress(request, thePart);
+                    this._promptPart = thePart;
+                }));
+                return { promise, part };
+            }
+        }
+        return { promise: Promise.resolve(false) };
+    }
+    async _assessOutputForErrors(buffer, token) {
+        const models = await this._languageModelsService.selectLanguageModels({ vendor: 'copilot', family: 'gpt-4o-mini' });
+        if (!models.length) {
+            return 'No models available';
+        }
+        const response = await this._languageModelsService.sendChatRequest(models[0], ( new ExtensionIdentifier('core')), [{ role: ChatMessageRole.User, content: [{ type: 'text', value: `Evaluate this terminal output to determine if there were errors. If there are errors, return them. Otherwise, return undefined: ${buffer}.` }] }], {}, token);
+        try {
+            const responseFromStream = getTextResponseFromStream(response);
+            await Promise.all([response.result, responseFromStream]);
+            return await responseFromStream;
+        }
+        catch (err) {
+            return 'Error occurred ' + err;
+        }
+    }
+    async _determineUserInputOptions(execution, token) {
+        if (token.isCancellationRequested) {
+            return;
+        }
+        const models = await this._languageModelsService.selectLanguageModels({ vendor: 'copilot', family: 'gpt-4o-mini' });
+        if (!models.length) {
+            return undefined;
+        }
+        const lastFiveLines = execution.getOutput(this._lastPromptMarker).trimEnd().split('\n').slice(-5).join('\n');
+        const promptText = `Analyze the following terminal output. If it contains a prompt requesting user input (such as a confirmation, selection, or yes/no question) and that prompt has NOT already been answered, extract the prompt text and the possible options as a JSON object with keys 'prompt' and 'options' (an array of strings or an object with option to description mappings). For example, if the options are "[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [C] Cancel", the option to description mappings would be {"Y": "Yes", "A": "Yes to All", "N": "No", "L": "No to All", "C": "Cancel"}. If there is no such prompt, return null.
+			Examples:
+			1. Output: "Do you want to overwrite? (y/n)"
+				Response: {"prompt": "Do you want to overwrite?", "options": ["y", "n"]}
+
+			2. Output: "Confirm: [Y] Yes  [A] Yes to All  [N] No  [L] No to All  [C] Cancel"
+				Response: {"prompt": "Confirm", "options": ["Y", "A", "N", "L", "C"]}
+
+			3. Output: "Accept license terms? (yes/no)"
+				Response: {"prompt": "Accept license terms?", "options": ["yes", "no"]}
+
+			4. Output: "Press Enter to continue"
+				Response: {"prompt": "Press Enter to continue", "options": ["Enter"]}
+
+			5. Output: "Type Yes to proceed"
+				Response: {"prompt": "Type Yes to proceed", "options": ["Yes"]}
+
+			6. Output: "Continue [y/N]"
+				Response: {"prompt": "Continue", "options": ["y", "N"]}
+
+			Now, analyze this output:
+			${lastFiveLines}
+			`;
+        const response = await this._languageModelsService.sendChatRequest(models[0], ( new ExtensionIdentifier('core')), [
+            { role: ChatMessageRole.User, content: [{ type: 'text', value: promptText }] }
+        ], {}, token);
+        const responseText = await getTextResponseFromStream(response);
+        try {
+            const match = responseText.match(/\{[\s\S]*\}/);
+            if (match) {
+                const obj = JSON.parse(match[0]);
+                if (isObject(obj) &&
+                    'prompt' in obj && isString(obj.prompt) &&
+                    'options' in obj) {
+                    if (Array.isArray(obj.options) && obj.options.every(isString)) {
+                        return { prompt: obj.prompt, options: obj.options };
+                    }
+                    else if (isObject(obj.options) && ( Object.values(obj.options)).every(isString)) {
+                        return { prompt: obj.prompt, options: ( Object.keys(obj.options)), descriptions: ( Object.values(obj.options)) };
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error('Failed to parse confirmation prompt from language model response:', err);
+        }
+        return undefined;
+    }
+    async _selectAndHandleOption(confirmationPrompt, token) {
+        if (!confirmationPrompt?.options.length) {
+            return undefined;
+        }
+        const model = this._chatWidgetService.getWidgetsByLocations(ChatAgentLocation.Panel)[0]?.input.currentLanguageModel;
+        if (!model) {
+            return undefined;
+        }
+        const models = await this._languageModelsService.selectLanguageModels({ vendor: 'copilot', family: model.replaceAll('copilot/', '') });
+        if (!models.length) {
+            return undefined;
+        }
+        const prompt = confirmationPrompt.prompt;
+        const options = confirmationPrompt.options;
+        const currentMarker = this._execution.instance.registerMarker();
+        if (!currentMarker) {
+            return undefined;
+        }
+        if (this._lastPrompt === prompt) {
+            return;
+        }
+        this._lastPromptMarker = currentMarker;
+        this._lastPrompt = prompt;
+        const promptText = `Given the following confirmation prompt and options from a terminal output, which option is the default?\nPrompt: "${prompt}"\nOptions: ${JSON.stringify(options)}\nRespond with only the option string.`;
+        const response = await this._languageModelsService.sendChatRequest(models[0], ( new ExtensionIdentifier('core')), [
+            { role: ChatMessageRole.User, content: [{ type: 'text', value: promptText }] }
+        ], {}, token);
+        const suggestedOption = (await getTextResponseFromStream(response)).trim();
+        if (suggestedOption) {
+            const index = confirmationPrompt.options.indexOf(suggestedOption);
+            const validOption = confirmationPrompt.options.find(opt => suggestedOption.replace(/['"`]/g, '').trim() === opt.replace(/['"`]/g, '').trim());
+            if (validOption && index > -1) {
+                const description = confirmationPrompt.descriptions?.[index];
+                return description ? { description, option: validOption } : validOption;
+            }
+        }
+        return undefined;
+    }
+    async _confirmRunInTerminal(suggestedOption, execution, confirmationPrompt) {
+        const chatModel = this._chatService.getSession(execution.sessionId);
+        if (!(chatModel instanceof ChatModel)) {
+            return undefined;
+        }
+        const request = chatModel.getRequests().at(-1);
+        if (!request) {
+            return undefined;
+        }
+        const suggestedOptionValue = typeof suggestedOption === 'string' ? suggestedOption : suggestedOption.option;
+        const userPrompt = ( new Promise(resolve => {
+            const thePart = this._register(( new ChatElicitationRequestPart(( new MarkdownString(( localize(11447, "The terminal is awaiting input.")))), ( new MarkdownString(( localize(
+                11448,
+                "{0}\n Do you want to send `{1}`{2} followed by `Enter` to the terminal?",
+                confirmationPrompt.prompt,
+                suggestedOptionValue,
+                typeof suggestedOption === 'string' ? '' : suggestedOption.description ? ' (' + suggestedOption.description + ')' : ''
+            )))), '', ( localize(11449, 'Allow')), ( localize(11450, 'Focus Terminal')), async (value) => {
+                thePart.state = 'accepted';
+                thePart.hide();
+                thePart.dispose();
+                let option = undefined;
+                if (value === true) {
+                    option = suggestedOptionValue;
+                }
+                else if (typeof value === 'object' && 'label' in value) {
+                    option = value.label.split(' (')[0];
+                }
+                this._outputMonitorTelemetryCounters.inputToolManualAcceptCount++;
+                this._outputMonitorTelemetryCounters.inputToolManualChars += option?.length || 0;
+                resolve(option);
+            }, async () => {
+                thePart.state = 'rejected';
+                thePart.hide();
+                this._state = OutputMonitorState.Cancelled;
+                this._outputMonitorTelemetryCounters.inputToolManualRejectCount++;
+                inputDataDisposable.dispose();
+                resolve(undefined);
+            }, undefined, getMoreActions(suggestedOption, confirmationPrompt))));
+            const inputDataDisposable = this._register(execution.instance.onDidInputData(() => {
+                thePart.hide();
+                thePart.dispose();
+                inputDataDisposable.dispose();
+                this._state = OutputMonitorState.PollingForIdle;
+                resolve(undefined);
+            }));
+            chatModel.acceptResponseProgress(request, thePart);
+        }));
+        const optionToRun = await userPrompt;
+        if (optionToRun) {
+            await execution.instance.sendText(optionToRun, true);
+        }
+        return optionToRun;
+    }
+};
+OutputMonitor = ( __decorate([
+    ( __param(5, ILanguageModelsService)),
+    ( __param(6, ITaskService)),
+    ( __param(7, IChatService)),
+    ( __param(8, IChatWidgetService))
+], OutputMonitor));
+function getMoreActions(suggestedOption, confirmationPrompt) {
+    const moreActions = [];
+    const moreOptions = confirmationPrompt.options.filter(a => a !== (typeof suggestedOption === 'string' ? suggestedOption : suggestedOption.option));
+    let i = 0;
+    for (const option of moreOptions) {
+        const label = option + (confirmationPrompt.descriptions ? ' (' + confirmationPrompt.descriptions[i] + ')' : '');
+        const action = {
+            label,
+            tooltip: label,
+            id: `terminal.poll.send.${option}`,
+            class: undefined,
+            enabled: true,
+            run: async () => { }
+        };
+        i++;
+        moreActions.push(action);
+    }
+    return moreActions.length ? moreActions : undefined;
+}
+
+export { OutputMonitor };

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

@@ -0,0 +1,45 @@
+import type { Task } from "@codingame/monaco-vscode-05a2a821-e4de-5941-b7f9-bbf01c09f229-common/vscode/vs/workbench/contrib/tasks/common/taskService";
+import type { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import type { ILinkLocation } from "../../taskHelpers.js";
+import type { IMarker as XtermMarker } from "@xterm/xterm";
+export interface IConfirmationPrompt {
+    prompt: string;
+    options: string[];
+    descriptions?: string[];
+}
+export interface IExecution {
+    getOutput: (marker?: XtermMarker) => string;
+    isActive?: () => Promise<boolean>;
+    task?: Task | Pick<Task, "configurationProperties">;
+    instance: Pick<ITerminalInstance, "sendText" | "instanceId" | "onDidInputData" | "onData" | "focus" | "registerMarker">;
+    sessionId: string;
+}
+export interface IPollingResult {
+    output: string;
+    resources?: ILinkLocation[];
+    modelOutputEvalResponse?: string;
+    state: OutputMonitorState;
+}
+export declare enum OutputMonitorState {
+    Initial = "Initial",
+    Idle = "Idle",
+    PollingForIdle = "PollingForIdle",
+    Prompting = "Prompting",
+    Timeout = "Timeout",
+    Active = "Active",
+    Cancelled = "Cancelled"
+}
+export interface IRacePollingOrPromptResult {
+    output: string;
+    pollDurationMs?: number;
+    modelOutputEvalResponse?: string;
+    state: OutputMonitorState;
+}
+export declare enum PollingConsts {
+    MinIdleEvents = 2,// Minimum number of idle checks before considering the terminal idle
+    MinPollingDuration = 500,
+    FirstPollingMaxDuration = 20000,// 20 seconds
+    ExtendedPollingMaxDuration = 120000,// 2 minutes
+    MaxPollingIntervalDuration = 2000,// 2 seconds
+    MaxRecursionCount = 5
+}

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/monitoring/types.js

@@ -0,0 +1,23 @@
+
+
+var OutputMonitorState;
+(function (OutputMonitorState) {
+    OutputMonitorState["Initial"] = "Initial";
+    OutputMonitorState["Idle"] = "Idle";
+    OutputMonitorState["PollingForIdle"] = "PollingForIdle";
+    OutputMonitorState["Prompting"] = "Prompting";
+    OutputMonitorState["Timeout"] = "Timeout";
+    OutputMonitorState["Active"] = "Active";
+    OutputMonitorState["Cancelled"] = "Cancelled";
+})(OutputMonitorState || (OutputMonitorState = {}));
+var PollingConsts;
+(function (PollingConsts) {
+    PollingConsts[PollingConsts["MinIdleEvents"] = 2] = "MinIdleEvents";
+    PollingConsts[PollingConsts["MinPollingDuration"] = 500] = "MinPollingDuration";
+    PollingConsts[PollingConsts["FirstPollingMaxDuration"] = 20000] = "FirstPollingMaxDuration";
+    PollingConsts[PollingConsts["ExtendedPollingMaxDuration"] = 120000] = "ExtendedPollingMaxDuration";
+    PollingConsts[PollingConsts["MaxPollingIntervalDuration"] = 2000] = "MaxPollingIntervalDuration";
+    PollingConsts[PollingConsts["MaxRecursionCount"] = 5] = "MaxRecursionCount";
+})(PollingConsts || (PollingConsts = {}));
+
+export { OutputMonitorState, PollingConsts };

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

@@ -0,0 +1,2 @@
+import { ILanguageModelChatResponse } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels";
+export declare function getTextResponseFromStream(response: ILanguageModelChatResponse): Promise<string>;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/monitoring/utils.js

@@ -0,0 +1,31 @@
+
+
+async function getTextResponseFromStream(response) {
+    let responseText = '';
+    const streaming = (async () => {
+        if (!response || !response.stream) {
+            return;
+        }
+        for await (const part of response.stream) {
+            if (Array.isArray(part)) {
+                for (const p of part) {
+                    if (p.type === 'text') {
+                        responseText += p.value;
+                    }
+                }
+            }
+            else if (part.type === 'text') {
+                responseText += part.value;
+            }
+        }
+    })();
+    try {
+        await Promise.all([response.result, streaming]);
+        return responseText;
+    }
+    catch (err) {
+        return 'Error occurred ' + err;
+    }
+}
+
+export { getTextResponseFromStream };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/{runInTerminalTool.d.ts → tools/runInTerminalTool.d.ts}

@@ -1,21 +1,18 @@
 import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+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 { 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 { 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 { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress } 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 { 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";
 import { ITerminalProfileResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal.service";
-import { CommandLineAutoApprover } from "./commandLineAutoApprover.js";
-import { type IToolTerminal } from "./toolTerminalCreator.js";
+import { CommandLineAutoApprover } from "../commandLineAutoApprover.js";
+import { type IToolTerminal } from "../toolTerminalCreator.js";
 export declare const RunInTerminalToolData: IToolData;
 export interface IRunInTerminalInputParams {
     command: string;
@@ -24,32 +21,33 @@ export interface IRunInTerminalInputParams {
 }
 export declare class RunInTerminalTool extends Disposable implements IToolImpl {
     private readonly _instantiationService;
+    private readonly _configurationService;
     private readonly _languageModelToolsService;
     private readonly _storageService;
-    private readonly _telemetryService;
     private readonly _logService;
     private readonly _terminalProfileResolverService;
     private readonly _terminalService;
     private readonly _remoteAgentService;
     private readonly _chatService;
-    private readonly _workspaceContextService;
-    private readonly _languageModelsService;
+    private readonly _terminalToolCreator;
+    private readonly _commandSimplifier;
+    private readonly _telemetry;
     protected readonly _commandLineAutoApprover: CommandLineAutoApprover;
     protected readonly _sessionTerminalAssociations: Map<string, IToolTerminal>;
     protected readonly _osBackend: Promise<OperatingSystem>;
-    private _alternativeRecommendation?;
     private static readonly _backgroundExecutions;
     static getBackgroundOutput(id: string): string;
-    constructor(_instantiationService: IInstantiationService, _languageModelToolsService: ILanguageModelToolsService, _storageService: IStorageService, _telemetryService: ITelemetryService, _logService: ITerminalLogService, _terminalProfileResolverService: ITerminalProfileResolverService, _terminalService: ITerminalService, _remoteAgentService: IRemoteAgentService, _chatService: IChatService, _workspaceContextService: IWorkspaceContextService, _languageModelsService: ILanguageModelsService);
+    constructor(_instantiationService: IInstantiationService, _configurationService: IConfigurationService, _languageModelToolsService: ILanguageModelToolsService, _storageService: IStorageService, _logService: ITerminalLogService, _terminalProfileResolverService: ITerminalProfileResolverService, _terminalService: ITerminalService, _remoteAgentService: IRemoteAgentService, _chatService: IChatService);
     prepareToolInvocation(context: IToolInvocationPreparationContext, token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
     invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
+    private _getCopilotShell;
     private _initBackgroundTerminal;
     private _initForegroundTerminal;
-    protected _rewriteCommandIfNeeded(args: IRunInTerminalInputParams, instance: Pick<ITerminalInstance, "getCwdResource"> | undefined, shell: string): Promise<string>;
+    private _registerInputListener;
     private _restoreTerminalAssociations;
     private _setupProcessIdAssociation;
     private _associateProcessIdWithSession;
     private _removeProcessIdAssociation;
     private _cleanupSessionTerminals;
-    private _sendTelemetry;
+    private _createAutoApproveInfo;
 }