agentHost: adopt activity events and fix client tool stall in subagent (#313603)

* agentHost: adopt activity events and fix client tool stall in subagent

* comments

Author: connor4312

src/vs/platform/agentHost/browser/remoteAgentHostProtocolClient.ts

@@ -300,6 +300,7 @@ export class RemoteAgentHostProtocolClient extends Disposable implements IAgentC
 			} : {}),
 			summary: s.title,
 			status: s.status,
+			activity: s.activity,
 			workingDirectory: typeof s.workingDirectory === 'string' ? toAgentHostUri(URI.parse(s.workingDirectory), this._connectionAuthority) : undefined,
 			isRead: !!(s.status & SessionStatus.IsRead),
 			isArchived: !!(s.status & SessionStatus.IsArchived),

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

@@ -82,6 +82,8 @@ export interface IAgentSessionMetadata {
 	readonly project?: IAgentSessionProjectInfo;
 	readonly summary?: string;
 	readonly status?: SessionStatus;
+	/** Human-readable description of what the session is currently doing. */
+	readonly activity?: string;
 	readonly model?: ModelSelection;
 	readonly workingDirectory?: URI;
 	readonly customizationDirectory?: URI;
@@ -268,6 +270,14 @@ export interface IAgentToolPendingConfirmationSignal {
 	readonly permissionKind?: 'shell' | 'write' | 'mcp' | 'read' | 'url' | 'custom-tool' | 'hook' | 'memory';
 	/** Host-only auto-approval path target (not part of the dispatched action). */
 	readonly permissionPath?: string;
+	/**
+	 * If set, the tool call belongs to the subagent rooted at this
+	 * parent tool call. Used by the host to route the resulting
+	 * `SessionToolCallReady` to the subagent session — otherwise the
+	 * action would land on the parent session, where there is no
+	 * matching `SessionToolCallStart`.
+	 */
+	readonly parentToolCallId?: string;
 }
 
 /**

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

@@ -334,6 +334,7 @@ export class AgentHostStateManager extends Disposable {
 			const changes: Partial<SessionSummary> = {};
 			if (current.title !== lastNotified.title) { changes.title = current.title; }
 			if (current.status !== lastNotified.status) { changes.status = current.status; }
+			if (current.activity !== lastNotified.activity) { changes.activity = current.activity; }
 			if (current.modifiedAt !== lastNotified.modifiedAt) { changes.modifiedAt = current.modifiedAt; }
 			if (current.project !== lastNotified.project) { changes.project = current.project; }
 			if (current.model !== lastNotified.model) { changes.model = current.model; }

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

@@ -202,6 +202,7 @@ export class AgentService extends Disposable implements IAgentService {
 					...s,
 					summary: liveState.summary.title || s.summary,
 					status: liveState.summary.status,
+					activity: liveState.summary.activity,
 					model: liveState.summary.model ?? s.model,
 				};
 			}

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

@@ -274,7 +274,15 @@ export class AgentSideEffects extends Disposable {
 		}
 
 		// Route signals with parentToolCallId to the subagent session.
-		const parentToolCallId = signal.kind === 'action' ? signal.parentToolCallId : undefined;
+		// Both action signals and pending_confirmation signals can carry
+		// a parentToolCallId — for client tools inside a subagent the
+		// permission flow fires `pending_confirmation` for an inner tool
+		// call, and that signal must be routed to the subagent session
+		// (otherwise the resulting SessionToolCallReady would land on the
+		// parent session, which has no matching SessionToolCallStart).
+		const parentToolCallId = signal.kind === 'action' || signal.kind === 'pending_confirmation'
+			? signal.parentToolCallId
+			: undefined;
 		if (parentToolCallId) {
 			const subagentKey = `${sessionKey}:${parentToolCallId}`;
 			const subagentSession = this._subagentSessions.get(subagentKey);
@@ -285,7 +293,7 @@ export class AgentSideEffects extends Disposable {
 				}
 				const subTurnId = this._stateManager.getActiveTurnId(subagentSession);
 				if (subTurnId) {
-					this._dispatchActionForSession(signal, subagentSession, subTurnId);
+					this._dispatchActionForSession(signal, subagentSession, subTurnId, agent);
 				}
 				return;
 			}
@@ -303,8 +311,9 @@ export class AgentSideEffects extends Disposable {
 		}
 
 		// Route pending_confirmation signals for tools inside subagent sessions
-		// (the signal lacks parentToolCallId, but the tool was previously
-		// registered under its subagent session key in _toolCallAgents).
+		// (legacy path for signals without an explicit parentToolCallId — the
+		// tool was previously registered under its subagent session key in
+		// _toolCallAgents).
 		if (signal.kind === 'pending_confirmation') {
 			const subagentSession = this._findSubagentSessionForToolCall(sessionKey, signal.state.toolCallId);
 			if (subagentSession) {

src/vs/platform/agentHost/node/copilot/copilotAgent.ts

@@ -769,7 +769,8 @@ export class CopilotAgent extends Disposable implements IAgent {
 	}
 
 	onClientToolCallComplete(session: URI, toolCallId: string, result: ToolCallResult): void {
-		const entry = this._sessions.get(AgentSession.id(session));
+		const sessionId = AgentSession.id(parseSubagentSessionUri(session.toString())?.parentSession || session);
+		const entry = this._sessions.get(sessionId);
 		entry?.handleClientToolCallComplete(toolCallId, result);
 	}
 

src/vs/platform/agentHost/node/copilot/copilotAgentSession.ts

@@ -150,7 +150,7 @@ export class CopilotAgentSession extends Disposable {
 	readonly sessionUri: URI;
 
 	/** Tracks active tool invocations so we can produce past-tense messages on completion. */
-	private readonly _activeToolCalls = new Map<string, { toolName: string; displayName: string; parameters: Record<string, unknown> | undefined; content: ToolResultContent[] }>();
+	private readonly _activeToolCalls = new Map<string, { toolName: string; displayName: string; parameters: Record<string, unknown> | undefined; content: ToolResultContent[]; parentToolCallId: string | undefined }>();
 	/** Pending permission requests awaiting a renderer-side decision. */
 	private readonly _pendingPermissions = new Map<string, DeferredPromise<boolean>>();
 	/** Pending user input requests awaiting a renderer-side answer. */
@@ -206,6 +206,8 @@ export class CopilotAgentSession extends Disposable {
 	private _currentMarkdownPartId: string | undefined;
 	/** Current reasoning response part ID for the active turn. Reset on each new turn. */
 	private _currentReasoningPartId: string | undefined;
+	/** Tracks whether a non-empty activity has been published, so we only emit a clear when needed. */
+	private _hasReportedActivity = false;
 
 	constructor(
 		options: ICopilotAgentSessionOptions,
@@ -612,6 +614,11 @@ export class CopilotAgentSession extends Disposable {
 
 			// Fire a pending_confirmation signal to transition the tool to PendingConfirmation
 			const toolName = request.toolName ?? request.kind;
+			// Forward the tool's parentToolCallId (if any) so the host can
+			// route the resulting SessionToolCallReady to the correct
+			// subagent session — without it the action would land on the
+			// parent session, which has no matching SessionToolCallStart.
+			const parentToolCallId = this._activeToolCalls.get(toolCallId)?.parentToolCallId;
 			this._onDidSessionProgress.fire({
 				kind: 'pending_confirmation',
 				session: this.sessionUri,
@@ -627,6 +634,7 @@ export class CopilotAgentSession extends Disposable {
 				},
 				permissionKind,
 				permissionPath,
+				parentToolCallId,
 			});
 
 			const approved = await deferred.p;
@@ -992,6 +1000,21 @@ export class CopilotAgentSession extends Disposable {
 		this._register(wrapper.onToolStart(e => {
 			if (isHiddenTool(e.data.toolName)) {
 				this._logService.trace(`[Copilot:${sessionId}] Tool started (hidden): ${e.data.toolName}`);
+				// The CLI uses the `report_intent` tool to signal what the
+				// agent is currently doing. Surface this as session activity
+				// so the UI can show a live "what is the agent doing now?"
+				// hint while the turn is in progress.
+				if (e.data.toolName === 'report_intent') {
+					const intent = (e.data.arguments as { intent?: unknown } | undefined)?.intent;
+					if (typeof intent === 'string' && intent.length > 0) {
+						this._hasReportedActivity = true;
+						this._emitAction({
+							type: ActionType.SessionActivityChanged,
+							session: this._protocolSession(),
+							activity: intent,
+						});
+					}
+				}
 				return;
 			}
 			this._logService.info(`[Copilot:${sessionId}] Tool started: ${e.data.toolName}`);
@@ -1007,7 +1030,7 @@ export class CopilotAgentSession extends Disposable {
 				toolArgs = tryStringify(parameters);
 			}
 			const displayName = getToolDisplayName(e.data.toolName);
-			this._activeToolCalls.set(e.data.toolCallId, { toolName: e.data.toolName, displayName, parameters, content: [] });
+			this._activeToolCalls.set(e.data.toolCallId, { toolName: e.data.toolName, displayName, parameters, content: [], parentToolCallId: e.data.parentToolCallId });
 			const toolKind = getToolKind(e.data.toolName);
 			const subagentMeta = toolKind === 'subagent' ? getSubagentMetadata(parameters) : undefined;
 			const toolClientId = this._clientToolNames.has(e.data.toolName) ? this._appliedSnapshot.clientId : undefined;
@@ -1124,6 +1147,17 @@ export class CopilotAgentSession extends Disposable {
 
 		this._register(wrapper.onIdle(() => {
 			this._logService.info(`[Copilot:${sessionId}] Session idle`);
+			// Clear any in-progress activity description set during the
+			// turn (e.g. via the `report_intent` tool) — the agent is no
+			// longer doing anything once the turn completes.
+			if (this._hasReportedActivity) {
+				this._hasReportedActivity = false;
+				this._emitAction({
+					type: ActionType.SessionActivityChanged,
+					session: this._protocolSession(),
+					activity: undefined,
+				});
+			}
 			this._emitAction({
 				type: ActionType.SessionTurnComplete,
 				session: this._protocolSession(),

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

@@ -509,6 +509,7 @@ export class ProtocolServerHandler extends Disposable {
 					provider,
 					title: s.summary ?? 'Session',
 					status,
+					activity: s.activity,
 					createdAt: s.startTime,
 					modifiedAt: s.modifiedTime,
 					...(s.project ? { project: { uri: s.project.uri.toString(), displayName: s.project.displayName } } : {}),

src/vs/platform/agentHost/test/node/agentSideEffects.test.ts

@@ -1069,6 +1069,83 @@ suite('AgentSideEffects', () => {
 			assert.strictEqual(part?.kind === ResponsePartKind.ToolCall ? part.toolCall.status : undefined, ToolCallStatus.PendingConfirmation,
 				'tool call should advance to PendingConfirmation for permission-gated tool_ready');
 		});
+
+		test('pending_confirmation for a tool inside a subagent routes to the subagent session', () => {
+			// Regression: a `pending_confirmation` signal for a client tool
+			// inside a subagent must dispatch SessionToolCallReady against
+			// the subagent session, not the parent. Otherwise the parent
+			// session sees a stray `session/toolCallReady` with no
+			// preceding `session/toolCallStart`, which is illegal.
+			setupSession();
+			startTurn('turn-1');
+			disposables.add(sideEffects.registerProgressListener(agent));
+
+			// Parent tool that delegates to a subagent.
+			agent.fireProgress({
+				kind: 'action', session: sessionUri,
+				action: {
+					type: ActionType.SessionToolCallStart, session: sessionUri.toString(), turnId: 'turn-1',
+					toolCallId: 'tc-parent', toolName: 'runSubagent', displayName: 'Run Subagent', toolClientId: undefined,
+					_meta: { toolKind: undefined, language: undefined },
+				},
+			});
+			agent.fireProgress({
+				kind: 'action', session: sessionUri,
+				action: {
+					type: ActionType.SessionToolCallReady, session: sessionUri.toString(), turnId: 'turn-1',
+					toolCallId: 'tc-parent', invocationMessage: 'Delegating...', toolInput: undefined,
+					confirmed: ToolCallConfirmationReason.NotNeeded,
+				},
+			});
+			agent.fireProgress({ kind: 'subagent_started', session: sessionUri, toolCallId: 'tc-parent', agentName: 'helper', agentDisplayName: 'Helper' });
+
+			// Inner client tool starts inside the subagent.
+			agent.fireProgress({
+				kind: 'action', session: sessionUri, parentToolCallId: 'tc-parent',
+				action: {
+					type: ActionType.SessionToolCallStart, session: sessionUri.toString(), turnId: 'turn-1',
+					toolCallId: 'tc-inner', toolName: 'problems', displayName: 'Problems', toolClientId: 'client-tools',
+					_meta: { toolKind: undefined, language: undefined },
+				},
+			});
+
+			// Permission flow fires `pending_confirmation` for the inner
+			// client tool. The signal must be routed to the subagent
+			// session — not to the parent — even though the signal carries
+			// only the parent session URI.
+			agent.fireProgress({
+				kind: 'pending_confirmation', session: sessionUri, parentToolCallId: 'tc-parent',
+				state: {
+					status: ToolCallStatus.PendingConfirmation,
+					toolCallId: 'tc-inner', toolName: 'problems', displayName: 'Problems',
+					invocationMessage: 'Get problems', toolInput: '{}',
+					confirmationTitle: undefined, edits: undefined,
+				},
+				permissionKind: 'custom-tool', permissionPath: undefined,
+			});
+
+			// The subagent session must contain the SessionToolCallReady.
+			const subagentUri = buildSubagentSessionUri(sessionUri.toString(), 'tc-parent');
+			const subState = stateManager.getSessionState(subagentUri);
+			const innerPart = subState?.activeTurn?.responseParts.find(
+				rp => rp.kind === ResponsePartKind.ToolCall && rp.toolCall.toolCallId === 'tc-inner'
+			);
+			assert.ok(innerPart, 'inner client tool call should exist on subagent session');
+			assert.strictEqual(
+				innerPart!.kind === ResponsePartKind.ToolCall ? innerPart.toolCall.status : undefined,
+				ToolCallStatus.Running,
+				'inner client tool call should advance to Running after pending_confirmation'
+			);
+
+			// The parent session must NOT have a stray tool call for the
+			// inner toolCallId — that would be a SessionToolCallReady
+			// without a matching SessionToolCallStart.
+			const parentState = stateManager.getSessionState(sessionUri.toString());
+			const parentInner = parentState?.activeTurn?.responseParts.find(
+				rp => rp.kind === ResponsePartKind.ToolCall && rp.toolCall.toolCallId === 'tc-inner'
+			);
+			assert.strictEqual(parentInner, undefined, 'parent session must not contain the inner tool call');
+		});
 	});
 
 	// ---- Session-level auto-approve (config) ----------------------------

src/vs/platform/agentHost/test/node/copilotAgent.test.ts

@@ -21,7 +21,7 @@ import { IAgentPluginManager, ISyncedCustomization } from '../../common/agentPlu
 import { AgentSession, type AgentSignal, type IAgentActionSignal, type IAgentSessionMetadata } from '../../common/agentService.js';
 import { ISessionDataService } from '../../common/sessionDataService.js';
 import { AHP_AUTH_REQUIRED, ProtocolError } from '../../common/state/sessionProtocol.js';
-import { ResponsePartKind, SessionCustomization, TurnState, type CustomizationRef, type MarkdownResponsePart, type Turn } from '../../common/state/sessionState.js';
+import { buildSubagentSessionUri, ResponsePartKind, SessionCustomization, TurnState, type CustomizationRef, type MarkdownResponsePart, type ToolCallResult, type Turn } from '../../common/state/sessionState.js';
 import { ActionType, type IDeltaAction } from '../../common/state/sessionActions.js';
 
 import { AgentConfigurationService, IAgentConfigurationService } from '../../node/agentConfigurationService.js';
@@ -500,6 +500,74 @@ suite('CopilotAgent', () => {
 		});
 	});
 
+	suite('onClientToolCallComplete', () => {
+
+		/**
+		 * Injects a stub session into the agent's `_sessions` map so we can
+		 * observe how `onClientToolCallComplete` resolves URIs to session
+		 * entries without standing up a full Copilot SDK session.
+		 */
+		function installStubSession(agent: CopilotAgent, sessionId: string): { calls: { toolCallId: string; result: ToolCallResult }[] } {
+			const calls: { toolCallId: string; result: ToolCallResult }[] = [];
+			const stub = {
+				handleClientToolCallComplete(toolCallId: string, result: ToolCallResult) {
+					calls.push({ toolCallId, result });
+				},
+				dispose() { },
+			};
+			const sessions = (agent as unknown as { _sessions: Map<string, unknown> })._sessions;
+			sessions.set(sessionId, stub);
+			return { calls };
+		}
+
+		test('routes a top-level session URI to its session entry', async () => {
+			const agent = createTestAgent(disposables);
+			try {
+				const sessionUri = AgentSession.uri('copilotcli', 'session-top');
+				const { calls } = installStubSession(agent, AgentSession.id(sessionUri));
+
+				const result: ToolCallResult = { success: true, pastTenseMessage: 'did it' };
+				agent.onClientToolCallComplete(sessionUri, 'tc-top', result);
+
+				assert.deepStrictEqual(calls, [{ toolCallId: 'tc-top', result }]);
+			} finally {
+				await disposeAgent(agent);
+			}
+		});
+
+		test('routes a subagent session URI to its parent session entry', async () => {
+			// Regression: client-tool completions for tools running inside a
+			// subagent are dispatched against the subagent session URI by
+			// the renderer. The agent must resolve that to the parent
+			// session entry — only the parent owns the SDK session and the
+			// pending deferred for the tool call.
+			const agent = createTestAgent(disposables);
+			try {
+				const parentUri = AgentSession.uri('copilotcli', 'session-parent');
+				const { calls } = installStubSession(agent, AgentSession.id(parentUri));
+
+				const subagentUri = URI.parse(buildSubagentSessionUri(parentUri.toString(), 'tc-parent'));
+				const result: ToolCallResult = { success: true, pastTenseMessage: 'subagent tool done' };
+				agent.onClientToolCallComplete(subagentUri, 'tc-inner', result);
+
+				assert.deepStrictEqual(calls, [{ toolCallId: 'tc-inner', result }]);
+			} finally {
+				await disposeAgent(agent);
+			}
+		});
+
+		test('is a no-op when no session entry exists for the resolved id', async () => {
+			const agent = createTestAgent(disposables);
+			try {
+				const sessionUri = AgentSession.uri('copilotcli', 'session-missing');
+				// No stub installed — the call should be silently ignored.
+				agent.onClientToolCallComplete(sessionUri, 'tc-x', { success: true, pastTenseMessage: 'noop' });
+			} finally {
+				await disposeAgent(agent);
+			}
+		});
+	});
+
 	suite('worktree announcement', () => {
 		// Drives a real session through worktree creation (calling the
 		// agent's _resolveSessionWorkingDirectory via a test seam so we don't