Merge pull request #308866 from microsoft/connor4312/ah-terminals-2

agentHost: integrate terminals with tool call

Author: connor4312

.vscode/launch.json

@@ -58,6 +58,8 @@
 			"request": "attach",
 			"name": "Attach to Agent Host Process",
 			"port": 5878,
+			"restart": true,
+			"timeout": 0,
 			"outFiles": [
 				"${workspaceFolder}/out/**/*.js"
 			]
@@ -819,5 +821,15 @@
 			],
 			"preLaunchTask": "Ensure Prelaunch Dependencies"
 		},
+		{
+			"name": "Renderer and Agent Host processes",
+			"stopAll": true,
+			"configurations": [
+				"Launch VS Code Internal",
+				"Attach to Main Process",
+				"Attach to Agent Host Process"
+			],
+			"preLaunchTask": "Ensure Prelaunch Dependencies"
+		},
 	]
 }

src/vs/platform/agentHost/common/state/sessionReducers.ts

@@ -6,23 +6,5 @@
 // Re-exports the protocol reducers and adds VS Code-specific helpers.
 // The actual reducer logic lives in the auto-generated protocol layer.
 
-import type { IToolCallState, ICompletedToolCall } from './sessionState.js';
-
 // Re-export reducers from the protocol layer
 export { rootReducer, sessionReducer, softAssertNever, isClientDispatchable } from './protocol/reducers.js';
-
-// ---- Tool call metadata helpers (VS Code extensions via _meta) --------------
-
-/**
- * Extracts the VS Code-specific `toolKind` rendering hint from a tool call's `_meta`.
- */
-export function getToolKind(tc: IToolCallState | ICompletedToolCall): 'terminal' | undefined {
-	return tc._meta?.toolKind as 'terminal' | undefined;
-}
-
-/**
- * Extracts the VS Code-specific `language` hint from a tool call's `_meta`.
- */
-export function getToolLanguage(tc: IToolCallState | ICompletedToolCall): string | undefined {
-	return tc._meta?.language as string | undefined;
-}

src/vs/platform/agentHost/node/agentHostMain.ts

@@ -13,6 +13,7 @@ import { URI } from '../../../base/common/uri.js';
 import * as os from 'os';
 import { AgentHostIpcChannels } from '../common/agentService.js';
 import { AgentService } from './agentService.js';
+import { IAgentHostTerminalManager } from './agentHostTerminalManager.js';
 import { CopilotAgent } from './copilot/copilotAgent.js';
 import { ProtocolServerHandler } from './protocolServerHandler.js';
 import { WebSocketProtocolServer } from './webSocketTransport.js';
@@ -89,6 +90,7 @@ function startAgentHost(): void {
 		const diffComputeService = disposables.add(new NodeWorkerDiffComputeService(logService));
 		diServices.set(IDiffComputeService, diffComputeService);
 
+		diServices.set(IAgentHostTerminalManager, agentService.terminalManager);
 		const instantiationService = new InstantiationService(diServices);
 		agentService.registerProvider(instantiationService.createInstance(CopilotAgent));
 	} catch (err) {

src/vs/platform/agentHost/node/agentHostServerMain.ts

@@ -31,6 +31,7 @@ import { InstantiationService } from '../../instantiation/common/instantiationSe
 import { ServiceCollection } from '../../instantiation/common/serviceCollection.js';
 import { CopilotAgent } from './copilot/copilotAgent.js';
 import { AgentService } from './agentService.js';
+import { IAgentHostTerminalManager } from './agentHostTerminalManager.js';
 import { WebSocketProtocolServer } from './webSocketTransport.js';
 import { ProtocolServerHandler } from './protocolServerHandler.js';
 import { FileService } from '../../files/common/fileService.js';
@@ -171,6 +172,7 @@ async function main(): Promise<void> {
 		diServices.set(ISessionDataService, sessionDataService);
 		diServices.set(IAgentPluginManager, pluginManager);
 		diServices.set(IDiffComputeService, disposables.add(new NodeWorkerDiffComputeService(logService)));
+		diServices.set(IAgentHostTerminalManager, agentService.terminalManager);
 		const instantiationService = new InstantiationService(diServices);
 		const copilotAgent = disposables.add(instantiationService.createInstance(CopilotAgent));
 		agentService.registerProvider(copilotAgent);

src/vs/platform/agentHost/node/agentHostTerminalManager.ts

@@ -3,15 +3,38 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { Disposable, DisposableStore, toDisposable } from '../../../base/common/lifecycle.js';
+import { Disposable, DisposableStore, IDisposable, toDisposable } from '../../../base/common/lifecycle.js';
+import { Emitter } from '../../../base/common/event.js';
 import * as platform from '../../../base/common/platform.js';
 import { ILogService } from '../../log/common/log.js';
+import { createDecorator } from '../../instantiation/common/instantiation.js';
 import { ActionType } from '../common/state/protocol/actions.js';
 import type { ICreateTerminalParams } from '../common/state/protocol/commands.js';
 import { ITerminalClaim, ITerminalInfo, ITerminalState, TerminalClaimKind } from '../common/state/protocol/state.js';
 import { isTerminalAction } from '../common/state/sessionActions.js';
 import type { AgentHostStateManager } from './agentHostStateManager.js';
 
+export const IAgentHostTerminalManager = createDecorator<IAgentHostTerminalManager>('agentHostTerminalManager');
+
+/**
+ * Service interface for terminal management in the agent host.
+ */
+export interface IAgentHostTerminalManager {
+	readonly _serviceBrand: undefined;
+	createTerminal(params: ICreateTerminalParams, options?: { shell?: string }): Promise<void>;
+	writeInput(uri: string, data: string): void;
+	onData(uri: string, cb: (data: string) => void): IDisposable;
+	onExit(uri: string, cb: (exitCode: number) => void): IDisposable;
+	onClaimChanged(uri: string, cb: (claim: ITerminalClaim) => void): IDisposable;
+	getContent(uri: string): string | undefined;
+	getClaim(uri: string): ITerminalClaim | undefined;
+	hasTerminal(uri: string): boolean;
+	getExitCode(uri: string): number | undefined;
+	disposeTerminal(uri: string): void;
+	getTerminalInfos(): ITerminalInfo[];
+	getTerminalState(uri: string): ITerminalState | undefined;
+}
+
 // node-pty is loaded dynamically to avoid bundling issues in non-node environments
 let nodePtyModule: typeof import('node-pty') | undefined;
 async function getNodePty(): Promise<typeof import('node-pty')> {
@@ -26,6 +49,9 @@ interface IManagedTerminal {
 	readonly uri: string;
 	readonly store: DisposableStore;
 	readonly pty: import('node-pty').IPty;
+	readonly onDataEmitter: Emitter<string>;
+	readonly onExitEmitter: Emitter<number>;
+	readonly onClaimChangedEmitter: Emitter<ITerminalClaim>;
 	title: string;
 	cwd: string;
 	cols: number;
@@ -43,7 +69,8 @@ interface IManagedTerminal {
  * actions (input, resize, claim changes) and dispatches server-originated
  * PTY output back through the state manager.
  */
-export class AgentHostTerminalManager extends Disposable {
+export class AgentHostTerminalManager extends Disposable implements IAgentHostTerminalManager {
+	declare readonly _serviceBrand: undefined;
 
 	private readonly _terminals = new Map<string, IManagedTerminal>();
 
@@ -110,7 +137,7 @@ export class AgentHostTerminalManager extends Disposable {
 	 * Create a new terminal backed by node-pty.
 	 * Spawns the user's default shell.
 	 */
-	async createTerminal(params: ICreateTerminalParams): Promise<void> {
+	async createTerminal(params: ICreateTerminalParams, options?: { shell?: string }): Promise<void> {
 		const uri = params.terminal;
 		if (this._terminals.has(uri)) {
 			throw new Error(`Terminal already exists: ${uri}`);
@@ -122,7 +149,7 @@ export class AgentHostTerminalManager extends Disposable {
 		const cols = params.cols ?? 80;
 		const rows = params.rows ?? 24;
 
-		const shell = this._getDefaultShell();
+		const shell = options?.shell ?? this._getDefaultShell();
 		const name = platform.isWindows ? 'cmd' : 'xterm-256color';
 
 		this._logService.info(`[TerminalManager] Creating terminal ${uri}: shell=${shell}, cwd=${cwd}, cols=${cols}, rows=${rows}`);
@@ -138,10 +165,17 @@ export class AgentHostTerminalManager extends Disposable {
 		const store = new DisposableStore();
 		const claim: ITerminalClaim = params.claim ?? { kind: TerminalClaimKind.Client, clientId: '' };
 
+		const onDataEmitter = store.add(new Emitter<string>());
+		const onExitEmitter = store.add(new Emitter<number>());
+		const onClaimChangedEmitter = store.add(new Emitter<ITerminalClaim>());
+
 		const managed: IManagedTerminal = {
 			uri,
 			store,
 			pty: ptyProcess,
+			onDataEmitter,
+			onExitEmitter,
+			onClaimChangedEmitter,
 			title: params.name ?? shell,
 			cwd,
 			cols,
@@ -162,6 +196,7 @@ export class AgentHostTerminalManager extends Disposable {
 			if (managed.content.length > 100_000) {
 				managed.content = managed.content.slice(-80_000);
 			}
+			managed.onDataEmitter.fire(data);
 			this._stateManager.dispatchServerAction({
 				type: ActionType.TerminalData,
 				terminal: uri,
@@ -172,6 +207,7 @@ export class AgentHostTerminalManager extends Disposable {
 
 		const exitListener = ptyProcess.onExit(e => {
 			managed.exitCode = e.exitCode;
+			managed.onExitEmitter.fire(e.exitCode);
 			this._stateManager.dispatchServerAction({
 				type: ActionType.TerminalExited,
 				terminal: uri,
@@ -201,14 +237,66 @@ export class AgentHostTerminalManager extends Disposable {
 		this._broadcastTerminalList();
 	}
 
-	/** Send input data to a terminal's PTY process. */
+	/** Send input data to a terminal's PTY process (from client-dispatched actions). */
 	private _writeInput(uri: string, data: string): void {
+		this.writeInput(uri, data);
+	}
+
+	/** Send input data to a terminal's PTY process. */
+	writeInput(uri: string, data: string): void {
 		const terminal = this._terminals.get(uri);
 		if (terminal && terminal.exitCode === undefined) {
 			terminal.pty.write(data);
 		}
 	}
 
+	/** Register a callback for PTY data events on a terminal. */
+	onData(uri: string, cb: (data: string) => void): IDisposable {
+		const terminal = this._terminals.get(uri);
+		if (!terminal) {
+			return toDisposable(() => { });
+		}
+		return terminal.onDataEmitter.event(cb);
+	}
+
+	/** Register a callback for PTY exit events on a terminal. */
+	onExit(uri: string, cb: (exitCode: number) => void): IDisposable {
+		const terminal = this._terminals.get(uri);
+		if (!terminal) {
+			return toDisposable(() => { });
+		}
+		return terminal.onExitEmitter.event(cb);
+	}
+
+	/** Register a callback for terminal claim changes. */
+	onClaimChanged(uri: string, cb: (claim: ITerminalClaim) => void): IDisposable {
+		const terminal = this._terminals.get(uri);
+		if (!terminal) {
+			return toDisposable(() => { });
+		}
+		return terminal.onClaimChangedEmitter.event(cb);
+	}
+
+	/** Get accumulated scrollback content for a terminal. */
+	getContent(uri: string): string | undefined {
+		return this._terminals.get(uri)?.content;
+	}
+
+	/** Get the current claim for a terminal. */
+	getClaim(uri: string): ITerminalClaim | undefined {
+		return this._terminals.get(uri)?.claim;
+	}
+
+	/** Check whether a terminal exists. */
+	hasTerminal(uri: string): boolean {
+		return this._terminals.has(uri);
+	}
+
+	/** Get the exit code for a terminal, or undefined if still running. */
+	getExitCode(uri: string): number | undefined {
+		return this._terminals.get(uri)?.exitCode;
+	}
+
 	/** Resize a terminal. */
 	private _resize(uri: string, cols: number, rows: number): void {
 		const terminal = this._terminals.get(uri);
@@ -224,6 +312,7 @@ export class AgentHostTerminalManager extends Disposable {
 		const terminal = this._terminals.get(uri);
 		if (terminal) {
 			terminal.claim = claim;
+			terminal.onClaimChangedEmitter.fire(claim);
 			this._broadcastTerminalList();
 		}
 	}

src/vs/platform/agentHost/node/agentService.ts

@@ -18,7 +18,7 @@ import type { ICreateTerminalParams } from '../common/state/protocol/commands.js
 import { AhpErrorCodes, AHP_SESSION_NOT_FOUND, ContentEncoding, JSON_RPC_INTERNAL_ERROR, ProtocolError, type IDirectoryEntry, type IResourceCopyParams, type IResourceCopyResult, type IResourceDeleteParams, type IResourceDeleteResult, type IResourceListResult, type IResourceMoveParams, type IResourceMoveResult, type IResourceReadResult, type IResourceWriteParams, type IResourceWriteResult, type IStateSnapshot } from '../common/state/sessionProtocol.js';
 import { ResponsePartKind, SessionStatus, ToolCallConfirmationReason, ToolCallStatus, TurnState, type IResponsePart, type ISessionFileDiff, type ISessionSummary, type IToolCallCompletedState, type ITurn } from '../common/state/sessionState.js';
 import { AgentSideEffects } from './agentSideEffects.js';
-import { AgentHostTerminalManager } from './agentHostTerminalManager.js';
+import { AgentHostTerminalManager, type IAgentHostTerminalManager } from './agentHostTerminalManager.js';
 import { ISessionDbUriFields, parseSessionDbUri } from './copilot/fileEditTracker.js';
 import { AgentHostStateManager } from './agentHostStateManager.js';
 
@@ -59,6 +59,9 @@ export class AgentService extends Disposable implements IAgentService {
 	/** Manages PTY-backed terminals for the agent host protocol. */
 	private readonly _terminalManager: AgentHostTerminalManager;
 
+	/** Exposes the terminal manager for use by agent providers. */
+	get terminalManager(): IAgentHostTerminalManager { return this._terminalManager; }
+
 	constructor(
 		private readonly _logService: ILogService,
 		private readonly _fileService: IFileService,