@codingame/monaco-vscode-chat-service-override 33.0.9 → 34.0.0

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

@@ -12,7 +12,7 @@ const GetTerminalLastCommandToolData = {
     id: TerminalToolId.TerminalLastCommand,
     toolReferenceName: "terminalLastCommand",
     legacyToolReferenceFullNames: ["runCommands/terminalLastCommand"],
-    displayName: ( localize(14463, "Get Terminal Last Command")),
+    displayName: ( localize(14652, "Get Terminal Last Command")),
     modelDescription: "Get the last command run in the active terminal.",
     source: ToolDataSource.Internal,
     icon: Codicon.terminal
@@ -24,8 +24,8 @@ let GetTerminalLastCommandTool = class GetTerminalLastCommandTool extends Dispos
     }
     async prepareToolInvocation(context, token) {
         return {
-            invocationMessage: ( localize(14464, "Getting last terminal command")),
-            pastTenseMessage: ( localize(14465, "Got last terminal command"))
+            invocationMessage: ( localize(14653, "Getting last terminal command")),
+            pastTenseMessage: ( localize(14654, "Got last terminal command"))
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {

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

@@ -10,11 +10,14 @@ export interface IGetTerminalOutputInputParams {
 export declare class GetTerminalOutputTool extends Disposable implements IToolImpl {
     private readonly _configurationService;
     private static readonly _maxOutputSnapshots;
+    private static readonly _tailCharBudget;
     private readonly _lastOutputSnapshotByExecutionId;
     constructor(_configurationService: IConfigurationService, terminalService: ITerminalService);
     prepareToolInvocation(context: IToolInvocationPreparationContext, token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
     invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
     private _formatOutput;
+    private _formatTailOrFull;
+    private _tailOf;
     private _rememberOutput;
     private _createOutputSnapshot;
     private _forgetTerminalInstance;

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

@@ -8,7 +8,7 @@ import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/pl
 import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
 import { ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
 import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
-import { RunInTerminalTool } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/runInTerminalTool';
+import { RunInTerminalTool } from './runInTerminalTool.js';
 import { TerminalToolId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/terminalToolIds';
 
 var GetTerminalOutputTool_1;
@@ -16,8 +16,8 @@ const GetTerminalOutputToolData = {
     id: TerminalToolId.GetTerminalOutput,
     toolReferenceName: "getTerminalOutput",
     legacyToolReferenceFullNames: ["runCommands/getTerminalOutput"],
-    displayName: ( localize(14466, "Get Terminal Output")),
-    modelDescription: `Get output from an active terminal execution (identified by the \`id\` returned from ${TerminalToolId.RunInTerminal}).`,
+    displayName: ( localize(14655, "Get Terminal Output")),
+    modelDescription: `Get output from an active terminal execution (identified by the \`id\` returned from ${TerminalToolId.RunInTerminal}). Use this to inspect output from a terminal started in async mode or a sync command that timed out and moved to the background. If a background command has not yet completed, you will be automatically notified when it finishes — do NOT poll; end your turn and wait.`,
     icon: Codicon.terminal,
     source: ToolDataSource.Internal,
     inputSchema: {
@@ -39,6 +39,9 @@ let GetTerminalOutputTool = class GetTerminalOutputTool extends Disposable {
     static {
         this._maxOutputSnapshots = 100;
     }
+    static {
+        this._tailCharBudget = 8000;
+    }
     constructor(_configurationService, terminalService) {
         super();
         this._configurationService = _configurationService;
@@ -49,8 +52,8 @@ let GetTerminalOutputTool = class GetTerminalOutputTool extends Disposable {
     }
     async prepareToolInvocation(context, token) {
         return {
-            invocationMessage: ( localize(14467, "Checking terminal output")),
-            pastTenseMessage: ( localize(14468, "Checked terminal output"))
+            invocationMessage: ( localize(14656, "Checking terminal output")),
+            pastTenseMessage: ( localize(14657, "Checked terminal output"))
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {
@@ -83,22 +86,41 @@ let GetTerminalOutputTool = class GetTerminalOutputTool extends Disposable {
     _formatOutput(id, terminalInstanceId, output) {
         if (!this._configurationService.getValue(TerminalChatAgentToolsSettingId.OutputDeltas)) {
             this._lastOutputSnapshotByExecutionId.clear();
-            return `Output of terminal ${id}:\n${output}`;
+            return this._formatTailOrFull(output, `Output of terminal ${id}`);
         }
         const previousOutputSnapshot = this._lastOutputSnapshotByExecutionId.get(id);
         const currentOutputSnapshot = this._createOutputSnapshot(terminalInstanceId, output);
         this._rememberOutput(id, currentOutputSnapshot);
         if (previousOutputSnapshot === undefined) {
-            return `Output of terminal ${id}:\n${output}`;
+            return this._formatTailOrFull(output, `Output of terminal ${id}`);
         }
         if (currentOutputSnapshot.length === previousOutputSnapshot.length && currentOutputSnapshot.hash === previousOutputSnapshot.hash) {
-            return `Output of terminal ${id} unchanged since previous poll (${output.length} characters already shown). No new output.`;
+            return `Output of terminal ${id} unchanged since previous poll (${output.length} total characters in buffer). No new output.`;
         }
         if (output.length > previousOutputSnapshot.length && this._hashOutput(output, previousOutputSnapshot.length) === previousOutputSnapshot.hash) {
             const delta = output.slice(previousOutputSnapshot.length);
             return `Output of terminal ${id} since previous poll (${delta.length} new characters, ${output.length} total characters):\n${delta}`;
         }
-        return `Output of terminal ${id} changed since previous poll; returning current output (${output.length} characters):\n${output}`;
+        return this._formatTailOrFull(output, `Output of terminal ${id} changed since previous poll`);
+    }
+    _formatTailOrFull(output, prefix) {
+        if (output.length <= GetTerminalOutputTool_1._tailCharBudget) {
+            return `${prefix}:\n${output}`;
+        }
+        const tail = this._tailOf(output, GetTerminalOutputTool_1._tailCharBudget);
+        const omitted = output.length - tail.length;
+        return `${prefix}; showing last ${tail.length} of ${output.length} characters (${omitted} earlier characters omitted). If you need the omitted earlier output, re-run the command and redirect output to a file, then read that file:\n${tail}`;
+    }
+    _tailOf(output, charBudget) {
+        if (output.length <= charBudget) {
+            return output;
+        }
+        const startIndex = output.length - charBudget;
+        const newlineIndex = output.indexOf("\n", startIndex);
+        if (newlineIndex !== -1 && newlineIndex < output.length - 1) {
+            return output.slice(newlineIndex + 1);
+        }
+        return output.slice(startIndex);
     }
     _rememberOutput(id, snapshot) {
         if (!( this._lastOutputSnapshotByExecutionId.has(id)) && this._lastOutputSnapshotByExecutionId.size >= GetTerminalOutputTool_1._maxOutputSnapshots) {

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

@@ -11,7 +11,7 @@ const GetTerminalSelectionToolData = {
     id: TerminalToolId.TerminalSelection,
     toolReferenceName: "terminalSelection",
     legacyToolReferenceFullNames: ["runCommands/terminalSelection"],
-    displayName: ( localize(14469, "Get Terminal Selection")),
+    displayName: ( localize(14658, "Get Terminal Selection")),
     modelDescription: "Get the current selection in the active terminal.",
     source: ToolDataSource.Internal,
     icon: Codicon.terminal
@@ -23,8 +23,8 @@ let GetTerminalSelectionTool = class GetTerminalSelectionTool extends Disposable
     }
     async prepareToolInvocation(context, token) {
         return {
-            invocationMessage: ( localize(14470, "Reading terminal selection")),
-            pastTenseMessage: ( localize(14471, "Read terminal selection"))
+            invocationMessage: ( localize(14659, "Reading terminal selection")),
+            pastTenseMessage: ( localize(14660, "Read terminal selection"))
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {

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

@@ -3,13 +3,13 @@ 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 { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
-import { RunInTerminalTool } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/runInTerminalTool';
+import { RunInTerminalTool } from './runInTerminalTool.js';
 import { TerminalToolId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/terminalToolIds';
 
 const KillTerminalToolData = {
     id: TerminalToolId.KillTerminal,
     toolReferenceName: "killTerminal",
-    displayName: ( localize(14472, "Kill Terminal")),
+    displayName: ( localize(14661, "Kill Terminal")),
     modelDescription: `Kill a terminal by its ID. Use this to clean up terminals that are no longer needed (e.g., after stopping a server or when a long-running task completes). The terminal ID is returned by ${TerminalToolId.RunInTerminal} in async mode (legacy: isBackground=true).`,
     icon: Codicon.terminal,
     source: ToolDataSource.Internal,
@@ -28,8 +28,8 @@ const KillTerminalToolData = {
 class KillTerminalTool extends Disposable {
     async prepareToolInvocation(_context, _token) {
         return {
-            invocationMessage: ( localize(14473, "Killing terminal")),
-            pastTenseMessage: ( localize(14474, "Killed terminal"))
+            invocationMessage: ( localize(14662, "Killing terminal")),
+            pastTenseMessage: ( localize(14663, "Killed terminal"))
         };
     }
     async invoke(invocation, _countTokens, _progress, _token) {

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

@@ -0,0 +1,177 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IToolInvocationContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+import { ITaskService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/taskService.service";
+import { IExecution, IPollingResult, OutputMonitorState } from "./types.js";
+import { ITerminalLogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service";
+export interface IOutputMonitor extends Disposable {
+    readonly pollingResult: IPollingResult & {
+        pollDurationMs: number;
+    } | undefined;
+    readonly outputMonitorTelemetryCounters: IOutputMonitorTelemetryCounters;
+    readonly onDidFinishCommand: Event<void>;
+    readonly onDidDetectInputNeeded: Event<void>;
+    /**
+     * Fires when the terminal is detected to be waiting for sensitive input
+     * (e.g. a password, passphrase, token, secret or verification code). This
+     * is fired *instead of* {@link onDidDetectInputNeeded} so callers can show
+     * UI that focuses the terminal rather than routing the prompt through the
+     * agent.
+     */
+    readonly onDidDetectSensitiveInputNeeded: Event<void>;
+}
+export interface IOutputMonitorTelemetryCounters {
+    inputToolManualAcceptCount: number;
+    inputToolManualRejectCount: number;
+    inputToolManualChars: number;
+    inputToolAutoAcceptCount: number;
+    inputToolAutoChars: number;
+    inputToolManualShownCount: number;
+    inputToolFreeFormInputShownCount: number;
+    inputToolFreeFormInputCount: number;
+}
+/**
+ * Returns the last visible line from terminal output after trimming trailing line breaks.
+ */
+export declare function getLastLine(output: string | undefined): string;
+export declare class OutputMonitor extends Disposable implements IOutputMonitor {
+    private readonly _execution;
+    private readonly _pollFn;
+    private readonly _taskService;
+    private readonly _logService;
+    private _state;
+    get state(): OutputMonitorState;
+    private _formatLastLineForLog;
+    private _pollingResult;
+    get pollingResult(): IPollingResult & {
+        pollDurationMs: number;
+    } | undefined;
+    /**
+     * Flag to track if user has inputted since idle was detected.
+     * This is used to skip showing prompts if the user already provided input.
+     */
+    private _userInputtedSinceIdleDetected;
+    private readonly _userInputListener;
+    private readonly _outputMonitorTelemetryCounters;
+    get outputMonitorTelemetryCounters(): Readonly<IOutputMonitorTelemetryCounters>;
+    private readonly _onDidFinishCommand;
+    readonly onDidFinishCommand: Event<void>;
+    private readonly _onDidDetectInputNeeded;
+    readonly onDidDetectInputNeeded: Event<void>;
+    private readonly _onDidDetectSensitiveInputNeeded;
+    readonly onDidDetectSensitiveInputNeeded: Event<void>;
+    private _asyncMode;
+    private _command;
+    private _invocationContext;
+    private _currentMonitoringCts;
+    /**
+     * Tracks whether onDidFinishCommand has fired so the event is delivered at
+     * most once. The event must fire synchronously during dispose so consumers
+     * awaiting `Event.toPromise(onDidFinishCommand)` are unblocked before the
+     * underlying emitter is torn down by super.dispose().
+     */
+    private _didFinish;
+    private _fireFinishedOnce;
+    dispose(): void;
+    constructor(_execution: IExecution, _pollFn: ((execution: IExecution, token: CancellationToken, taskService: ITaskService) => Promise<IPollingResult | undefined>) | undefined, invocationContext: IToolInvocationContext | undefined, token: CancellationToken, command: string, _taskService: ITaskService, _logService: ITerminalLogService);
+    private _startMonitoring;
+    /**
+     * Continues monitoring in background mode with a new cancellation token.
+     * In background mode, the monitor re-polls for idle and handles prompts
+     * whenever new terminal data arrives, rather than stopping after the first
+     * idle detection. Resource cost is bounded because the monitor only wakes
+     * on new terminal data (via {@link _waitForNewData}) and each idle cycle
+     * is capped by the standard polling timeouts.
+     */
+    continueMonitoringAsync(token: CancellationToken): void;
+    /**
+     * Waits for new terminal data or cancellation. Used in background mode
+     * to avoid polling and LLM calls while the terminal is quiet.
+     */
+    private _waitForNewData;
+    private _handleIdleState;
+    private _handleTimeoutState;
+    /**
+     * Single bounded polling pass that returns when:
+     *  - terminal becomes inactive/idle, or
+     *  - timeout window elapses.
+     */
+    private _waitForIdle;
+    /**
+     * Sets up a listener for user input that triggers immediately when idle is detected.
+     * This ensures we catch any input that happens between idle detection and prompt creation.
+     */
+    private _setupIdleInputListener;
+    /**
+     * Cleans up the idle input listener and resets the flag.
+     */
+    private _cleanupIdleInputListener;
+    private _isSensitivePrompt;
+}
+/**
+ * Returns true when the terminal's last visible line looks like a prompt for
+ * a sensitive secret (password, passphrase, token, API key, OTP, etc.). Used
+ * to short-circuit the normal "input needed → return to agent" flow so that
+ * the secret is never routed through the model — instead the user is asked
+ * via UI to focus the terminal and type the secret directly.
+ */
+export declare function detectsSensitiveInputPrompt(cursorLine: string): boolean;
+export declare function matchTerminalPromptOption(options: readonly string[], suggestedOption: string): {
+    option: string | undefined;
+    index: number;
+};
+/**
+ * High-confidence patterns that reliably indicate the terminal is waiting for
+ * input. These are safe to use as a fast-path in `_waitForIdle` to skip normal
+ * idle detection, because they are specific enough to avoid false positives on
+ * normal command output (build logs, headers, etc.).
+ */
+export declare function detectsHighConfidenceInputPattern(cursorLine: string): boolean;
+/**
+ * Strict input-required detection. Returns true only for patterns that are
+ * specific enough to avoid false positives on normal command output (build
+ * logs, status lines, error messages). Safe to call from any code path,
+ * including unconditionally on the last line of a finished command.
+ *
+ * For the broader heuristics (bare `:` / `?` with trailing space), use
+ * {@link detectsLikelyInputRequiredPattern} — but only from a call site that
+ * has independent evidence the command is still running and consuming stdin
+ * (e.g. `execution.isActive() === true`). Those broad patterns cannot
+ * reliably distinguish a real prompt like `Enter your name: ` from log
+ * output like `Last Command: ` on a single line.
+ */
+export declare function detectsInputRequiredPattern(cursorLine: string): boolean;
+/**
+ * Strict patterns plus broader heuristics (bare `:` and `?` with trailing
+ * space). These broad patterns may produce false positives on normal command
+ * output that happens to end with those characters (e.g. `Last Command: `,
+ * `[INFO] Starting: `, `find: /tmp/x: No such file: `). They are
+ * syntactically indistinguishable from real prompts like `Enter your name: `
+ * on a single cursor line.
+ *
+ * Therefore this function is only safe to call when the caller has
+ * independent evidence that the terminal is currently consuming stdin —
+ * specifically, `execution.isActive() === true` at a moment when the output
+ * stream has been quiet (idle) for several poll intervals. `_waitForIdle`
+ * applies that gate; new call sites should preserve it.
+ *
+ * For unconditional checks (e.g. on the last line of a finished command),
+ * use {@link detectsInputRequiredPattern} instead.
+ */
+export declare function detectsLikelyInputRequiredPattern(cursorLine: string): boolean;
+export declare function detectsNonInteractiveHelpPattern(cursorLine: string): boolean;
+/**
+ * Detects VS Code's specific task completion messages like:
+ * - "Press any key to close the terminal."
+ * - "Terminal will be reused by tasks, press any key to close it."
+ * These appear when a task finishes and should be ignored if the task is done.
+ * Note: These messages may be prefixed with " * " by VS Code and may have line wrapping
+ * that can split words across lines (e.g., "t\no" instead of "to").
+ */
+export declare function detectsVSCodeTaskFinishMessage(cursorLine: string): boolean;
+/**
+ * Detects generic "press any key" prompts from scripts (not VS Code task messages).
+ * These should prompt the user to interact with the terminal.
+ */
+export declare function detectsGenericPressAnyKeyPattern(cursorLine: string): boolean;