agentHost: chats with their own harness in a session (multipleChatProviders)

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

@@ -64,7 +64,9 @@ import { MessageAttachmentKind, SessionSummary, ROOT_STATE_URI, StateComponents,
 import type { AgentChatMoveDestination } from '../common/agentHostChatMove.js';
 import { ChatMoveDestinationKind } from '../common/state/protocol/channels-chat/commands.js';
 import { normalizeLegacyActionEnvelope } from '../common/state/legacyProtocolCompatibility.js';
-import { getAgentHostSupportedProtocolVersions } from '../common/agentHostProtocolCompatibility.js';
+import { getAgentHostClientProtocolVersions } from '../common/agentHostProtocolCompatibility.js';
+import { ChatProvidersConfigKey, ChatProvidersSettingId } from '../common/agentHostChatProviders.js';
+import { compareProtocolVersions } from '../common/state/protocol/version/registry.js';
 import { isJsonRpcNotification, isJsonRpcRequest, isJsonRpcResponse, ProtocolError, ReconnectResultType, JSON_RPC_INTERNAL_ERROR, type ProtocolMessage, type IStateSnapshot, type SubscribeResult, type JsonRpcNotification } from '../common/state/sessionProtocol.js';
 import { type IVscodeUpgradeResult } from '../common/state/protocolUpgrade.js';
 import { isClientTransport, NonReconnectableTransportError, type AgentHostTransportFailureReason, type IProtocolTransport } from '../common/state/sessionTransport.js';
@@ -100,6 +102,9 @@ import type { IDevContainerAgentHostMainService } from '../common/devContainerAg
 
 const AHP_CLIENT_CONNECTION_CLOSED = -32000;
 
+/** The first protocol version whose hosts may advertise `multipleChatProviders`. */
+const MULTIPLE_CHAT_PROVIDERS_PROTOCOL_VERSION = '1.1.0';
+
 function toAgentExtensionMode(value: unknown): AgentExtensionMode | undefined {
 	if (typeof value !== 'string') {
 		return undefined;
@@ -337,6 +342,12 @@ export class AgentHostProtocolClient extends Disposable implements IAgentConnect
 	private _relayRootRefresh: { readonly transport: IProtocolTransport; readonly promise: Promise<void> } | undefined;
 	/** Disposable holding the listeners attached to the current transport. */
 	private readonly _transportListeners = this._register(new MutableDisposable<DisposableStore>());
+	/** The next reconnect sends `initialize` instead of `reconnect`, so the host decides its capabilities again. */
+	private _freshInitializeRequested = false;
+	/** Whether to name the chat subscriptions held once the re-initialize for chats with their own agents connects. */
+	private _describeChatSubscriptionsOnReconnect = false;
+	/** Whether this connection already re-initialized for `multipleChatProviders` since the host's gate last turned on. */
+	private _reinitializedForChatProviders = false;
 	private readonly _connectionAuthority: string;
 	readonly resourceUris: IAgentHostResourceUriMapper;
 	private _serverSeq = 0;
@@ -562,6 +573,11 @@ export class AgentHostProtocolClient extends Disposable implements IAgentConnect
 			: undefined;
 	}
 
+	/** The versions offered in `initialize`; read on every connection, so the setting applies from the next one. */
+	private _offeredProtocolVersions(): string[] {
+		return getAgentHostClientProtocolVersions(this._configurationService.getValue<boolean>(ChatProvidersSettingId.Enabled) === true);
+	}
+
 	/**
 	 * The latest `initialize` response from the host, or `undefined` if
 	 * the handshake has not completed yet. Exposed observably so callers can
@@ -627,6 +643,9 @@ export class AgentHostProtocolClient extends Disposable implements IAgentConnect
 		this._register(this.onDidAction(envelope => {
 			this._subscriptionManager.receiveEnvelope(envelope);
 		}));
+		// The host's gate for chats with their own agents usually turns on through this client's own mirror, after the handshake.
+		this._register(this._subscriptionManager.rootState.onDidChange(() => this._maybeReinitializeForChatProviders()));
+		this._register(this.onDidChangeConnectionState(() => this._maybeReinitializeForChatProviders()));
 
 		this._register(this._configurationService.onDidChangeConfiguration(e => {
 			if (this._state.kind !== AgentHostClientState.Connected || this._isWebPubSubRelay()) {
@@ -656,6 +675,10 @@ export class AgentHostProtocolClient extends Disposable implements IAgentConnect
 				this._logService.info(`[RemoteAgentHostProtocol] Mirroring configuration to host root config from ${ConfigurationTargetToString(e.source)}: ${mirrored.join(', ')}`);
 				this._dispatchRootConfig(patch);
 			}
+			if (e.affectsConfiguration(ChatProvidersSettingId.Enabled)) {
+				// The host's gate may already be on (e.g. mirrored by another window), so its root state won't change.
+				this._maybeReinitializeForChatProviders();
+			}
 			if (e.affectsConfiguration(GLOBAL_AUTO_APPROVE_SETTING_ID)) {
 				this._updateAutoApprovePolicyRestriction();
 			}
@@ -860,7 +883,7 @@ export class AgentHostProtocolClient extends Disposable implements IAgentConnect
 				// Advertise every compatible version, most-preferred first, so an
 				// older host (a cloud sandbox running a 0.5.x `copilotd`) can negotiate down
 				// instead of rejecting the connection. A current host still picks the newest.
-				protocolVersions: getAgentHostSupportedProtocolVersions(),
+				protocolVersions: this._offeredProtocolVersions(),
 				clientId: this._clientId,
 				clientInfo: this._clientInfo,
 				_meta: this._clientMeta(),
@@ -1221,7 +1244,12 @@ export class AgentHostProtocolClient extends Disposable implements IAgentConnect
 	}
 
 	private async _reconnectOrInitialize(lastSeenServerSeq: number, subscriptions: string[]): Promise<{ result: CommandMap['reconnect']['result'] & { readonly _meta?: Record<string, unknown> }; freshInitialize: boolean }> {
+		const freshInitialize = this._freshInitializeRequested;
+		this._freshInitializeRequested = false;
 		try {
+			if (freshInitialize) {
+				throw new ProtocolError(AhpErrorCodes.NotFound, 'A fresh initialize was requested');
+			}
 			const result = await this._dispatchRequest<CommandMap['reconnect']['result'] & { readonly _meta?: Record<string, unknown> }>('reconnect', {
 				channel: ROOT_STATE_URI,
 				clientId: this._clientId,
@@ -1236,10 +1264,12 @@ export class AgentHostProtocolClient extends Disposable implements IAgentConnect
 			}
 		}
 
-		this._logService.info(`[RemoteAgentHostProtocol] Server forgot client ${this._clientId}; initializing a fresh connection.`);
+		this._logService.info(freshInitialize
+			? `[RemoteAgentHostProtocol] Re-initializing ${this._address} so the host decides its capabilities again.`
+			: `[RemoteAgentHostProtocol] Server forgot client ${this._clientId}; initializing a fresh connection.`);
 		const initializeResult = await this._dispatchRequest<IAgentHostExtensionInitializeResult>('initialize', {
 			channel: ROOT_STATE_URI,
-			protocolVersions: getAgentHostSupportedProtocolVersions(),
+			protocolVersions: this._offeredProtocolVersions(),
 			clientId: this._clientId,
 			clientInfo: this._clientInfo,
 			_meta: this._clientMeta(),
@@ -1539,6 +1569,68 @@ export class AgentHostProtocolClient extends Disposable implements IAgentConnect
 		}
 	}
 
+	/**
+	 * The host decides `multipleChatProviders` from its root config at the
+	 * handshake, but this client mirrors `multipleChatProviders.enabled` only
+	 * after it, and offers the protocol version that may advertise it only
+	 * while the setting is on. When the setting is on, the host's gate is on
+	 * (as confirmed by the host's root state), and the handshake didn't
+	 * advertise the capability, re-initialize once so the host decides again,
+	 * including when the handshake negotiated an older version because the
+	 * setting was off then. At most once until the host's gate or the setting
+	 * turns off again, so it never loops; nothing happens with the setting off.
+	 */
+	/**
+	 * The chat subscriptions this client holds, by holder: every one is restored after a re-initialize, so this
+	 * names the components that make a re-initialize restore many chats.
+	 */
+	private _describeChatSubscriptions(): string {
+		const holders = new Map<string, number>();
+		let count = 0;
+		for (const subscription of this._subscriptionManager.getActiveSubscriptions()) {
+			if (subscription.kind === StateComponents.Chat) {
+				count++;
+				for (const holder of subscription.holders) {
+					holders.set(holder.owner, (holders.get(holder.owner) ?? 0) + holder.count);
+				}
+			}
+		}
+		return `${count} chat subscription(s) held by: ${[...holders].map(([owner, holderCount]) => `${owner}=${holderCount}`).join(', ') || 'none'}`;
+	}
+
+	private _maybeReinitializeForChatProviders(): void {
+		if (this._describeChatSubscriptionsOnReconnect && this._state.kind === AgentHostClientState.Connected) {
+			this._describeChatSubscriptionsOnReconnect = false;
+			this._logService.trace(`[RemoteAgentHostProtocol] ${this._address} re-initialized for chats with their own agents with ${this._describeChatSubscriptions()}.`);
+		}
+		if (this._configurationService.getValue<boolean>(ChatProvidersSettingId.Enabled) !== true) {
+			this._reinitializedForChatProviders = false;
+			return;
+		}
+		if (this._state.kind !== AgentHostClientState.Connected || !this._transportFactory) {
+			return;
+		}
+		const root = this._subscriptionManager.rootState.value;
+		if (!root || root instanceof Error || root.config?.values[ChatProvidersConfigKey.Enabled] !== true) {
+			this._reinitializedForChatProviders = false;
+			return;
+		}
+		const result = this._initializeResult.get();
+		if (!result || result.multipleChatProviders || this._reinitializedForChatProviders
+			|| !this._offeredProtocolVersions().some(version => compareProtocolVersions(version, MULTIPLE_CHAT_PROVIDERS_PROTOCOL_VERSION) >= 0)) {
+			return;
+		}
+		this._reinitializedForChatProviders = true;
+		this._freshInitializeRequested = true;
+		this._logService.info(`[RemoteAgentHostProtocol] ${this._address} enabled chats with their own agents after the handshake; re-initializing.`);
+		this._logService.trace(`[RemoteAgentHostProtocol] ${this._address} re-initializing with ${this._describeChatSubscriptions()}.`);
+		this._describeChatSubscriptionsOnReconnect = true;
+		// Disposing the listeners closes the transport; route the close through the soft-reconnect path, as the watchdog does.
+		this._transportListeners.clear();
+		this._handleTransportClose();
+	}
+
+
 	private _updateDynamicAutoTiers(): void {
 		const enabled = getGlobalConfigurationValue<boolean>(this._configurationService, AgentHostDynamicAutoTiersEnabledSettingId) === true;
 		this._dispatchRootConfig({ [CopilotCliConfigKey.DynamicAutoTiers]: enabled });
@@ -1853,7 +1945,21 @@ export class AgentHostProtocolClient extends Disposable implements IAgentConnect
 
 	private async _subscribe(resource: URI): Promise<IStateSnapshot> {
 		this._logService.trace(`[RemoteAgentHostProtocol] subscribe start: ${resource.toString()}`);
-		const result = await this._sendRequest('subscribe', { channel: resource.toString() });
+		let result: CommandMap['subscribe']['result'];
+		while (true) {
+			try {
+				result = await this._sendRequest('subscribe', { channel: resource.toString() });
+				break;
+			} catch (error) {
+				// A subscribe in flight when the transport drops (a soft reconnect, or the re-initialize that enables
+				// chats with their own agents) is rejected only because its reply was lost: send it again once the
+				// client reconnects, as any request issued while reconnecting is, instead of failing the subscription.
+				if (!isConnectionClosedError(error) || (this._state as ClientState).kind !== AgentHostClientState.Reconnecting) {
+					throw error;
+				}
+				this._logService.trace(`[RemoteAgentHostProtocol] subscribe lost to a reconnect, retrying once reconnected: ${resource.toString()}`);
+			}
+		}
 		if (!result.snapshot) {
 			throw new Error(`subscribe to ${resource.toString()} returned no snapshot`);
 		}
@@ -2542,6 +2648,7 @@ export class AgentHostProtocolClient extends Disposable implements IAgentConnect
 			channel: session.toString(),
 			chat: chat.toString(),
 			...(options?.title !== undefined ? { title: options.title } : {}),
+			...(options?.provider !== undefined ? { provider: options.provider } : {}),
 			...(initialMessage ? { initialMessage } : {}),
 			...(options?.workingDirectories !== undefined && !options.fork
 				? { workingDirectories: options.workingDirectories.map(directory => fromAgentHostUri(directory).toString()) }
@@ -2635,6 +2742,7 @@ export class AgentHostProtocolClient extends Disposable implements IAgentConnect
 					summary: chat.title,
 					kind: s.defaultChat === chat.resource ? 'default' : 'peer',
 					origin: chat.origin,
+					...(chat.provider !== undefined ? { provider: chat.provider } : {}),
 					...(chat.interactivity !== undefined ? { interactivity: chat.interactivity } : {}),
 					...(isSessionChatArchived(chat) ? { archived: true } : {}),
 					...(chat.status !== undefined ? { status: chat.status, isRead: isSessionStatusRead(chat.status) } : {}),

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

@@ -204,6 +204,8 @@ export interface IAgentSessionChatMetadata {
 	readonly kind: 'default' | 'peer';
 	readonly origin?: ChatOrigin;
 	readonly interactivity?: ChatInteractivity;
+	/** The chat's own agent when it differs from its session's; absence means the session's agent. */
+	readonly provider?: string;
 	readonly archived?: boolean;
 	/** Exact chat read state when known; absence means the provider did not supply it. */
 	readonly isRead?: boolean;
@@ -1013,6 +1015,13 @@ export interface IAgentCreateChatRequestOptions extends IAgentCreateChatOptions
 	 * the provider, while retaining the side-chat provenance itself.
 	 */
 	readonly sideChat?: IAgentCreateChatSideChatSource;
+	/**
+	 * The agent requested for the new chat (`CreateChatParams.provider`). The
+	 * host resolves and validates it and creates the chat in that agent;
+	 * absent means the source chat's agent for a fork or side chat, else the
+	 * session's. Never passed to providers.
+	 */
+	readonly provider?: AgentProvider;
 	/**
 	 * Host-owned workspace requested for a new peer chat. The host prepares it
 	 * (adding the folder to the session, creating a worktree or a scratch

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

@@ -116,6 +116,24 @@ export const enum AgentChatMoveRefusal {
 	 * credentials than the destination session."
 	 */
 	DifferentCredentialOwner = 'differentCredentialOwner',
+	/**
+	 * Chats with their own agents are on, but the chat's agent is unknown or disabled on the host, so it can't move to a
+	 * session of another agent or become a session of its own agent. Client text: enable the chat's agent. Distinct from
+	 * {@link DifferentProvider}, which means chats with their own agents are off.
+	 */
+	AgentUnavailable = 'agentUnavailable',
+	/**
+	 * Chats with their own agents are on, but the destination's agent can't host chats of other agents, or the chat's
+	 * agent can't join a session of another agent: one of them doesn't support multiple chats. Client text: pick a
+	 * session of an agent that supports chats of other agents.
+	 */
+	AgentWithoutChats = 'agentWithoutChats',
+	/**
+	 * The chat's agent couldn't describe its settings for the chat when it moved into a session of another agent or
+	 * into a new session of its own agent. Transient: client text asks to try again. Distinct from {@link Unsupported}
+	 * (no conversation of its own to take into a new session).
+	 */
+	AgentConfigUnavailable = 'agentConfigUnavailable',
 }
 
 /** A chat move the host refused before changing anything. */

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

@@ -0,0 +1,39 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { localize } from '../../../nls.js';
+import { createSchema, schemaProperty } from './agentHostSchema.js';
+
+/** Host root config keys for chats of one session using different agents. */
+export const ChatProvidersConfigKey = {
+	Enabled: 'multipleChatProviders.enabled',
+} as const;
+
+/** Workbench settings mirrored into {@link ChatProvidersConfigKey}. */
+export const ChatProvidersSettingId = {
+	Enabled: 'chat.agentHost.multipleChatProviders.enabled',
+} as const;
+
+export const chatProvidersRootConfigSchema = createSchema({
+	[ChatProvidersConfigKey.Enabled]: schemaProperty<boolean>({
+		type: 'boolean',
+		title: localize('multipleChatProviders.config.enabled', "Multiple Chat Providers"),
+		default: false,
+	}),
+});
+
+/**
+ * The user-facing harness id of an agent provider, as clients present it:
+ * Copilot's `copilotcli` agent is the `copilot` harness; every other agent id
+ * is its own harness id.
+ */
+export function toAgentHostChatHarness(agentProvider: string): string {
+	return agentProvider === 'copilotcli' ? 'copilot' : agentProvider;
+}
+
+/** The agent provider of a user-facing harness id; the inverse of {@link toAgentHostChatHarness}. */
+export function fromAgentHostChatHarness(harness: string): string {
+	return harness === 'copilot' ? 'copilotcli' : harness;
+}

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

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { getErrorMessage } from '../../../base/common/errors.js';
-import { compareProtocolVersions, negotiateProtocolVersion, SUPPORTED_PROTOCOL_VERSIONS } from './state/protocol/version/registry.js';
+import { compareProtocolVersions, negotiateProtocolVersion, PROTOCOL_VERSION, SUPPORTED_PROTOCOL_VERSIONS } from './state/protocol/version/registry.js';
 import { JsonRpcErrorCodes, ProtocolError } from './state/sessionProtocol.js';
 
 const legacyCompatibleProtocolVersion = '0.10.0';
@@ -25,3 +25,15 @@ export function negotiateAgentHostProtocolVersion(offered: readonly string[]): s
 export function getAgentHostSupportedProtocolVersions(): string[] {
 	return [...SUPPORTED_PROTOCOL_VERSIONS, legacyCompatibleProtocolVersion].sort((a, b) => compareProtocolVersions(b, a));
 }
+
+/**
+ * The protocol versions a client offers in `initialize`, most-preferred first.
+ * With chats of one session using different agents enabled, the client also
+ * offers the current {@link PROTOCOL_VERSION} first, which hosts require
+ * before advertising `multipleChatProviders`; otherwise the offer is exactly
+ * {@link getAgentHostSupportedProtocolVersions}.
+ */
+export function getAgentHostClientProtocolVersions(multipleChatProviders: boolean): string[] {
+	const supported = getAgentHostSupportedProtocolVersions();
+	return multipleChatProviders && !supported.includes(PROTOCOL_VERSION) ? [PROTOCOL_VERSION, ...supported] : supported;
+}

src/vs/platform/agentHost/common/agentHostStarter.config.contribution.ts

@@ -58,6 +58,7 @@ import {
 	AgentHostWorkspaceSnapshotEnabledConfigKey,
 } from './agentHostSchema.js';
 import { AgentMergeConfigKey, AgentMergeSettingId, AGENT_MERGE_SETTING_TAG } from './agentMerge.js';
+import { ChatProvidersConfigKey, ChatProvidersSettingId } from './agentHostChatProviders.js';
 import { artifactToolsConfigurationProperties } from './artifactToolsConfiguration.js';
 import { chatMoveConfigurationProperties } from './chatMoveConfiguration.js';
 import { titleGenerationConfigurationProperties } from './titleGenerationConfiguration.js';
@@ -217,6 +218,14 @@ configurationRegistry.registerConfiguration({
 			tags: ['experimental', AGENT_MERGE_SETTING_TAG],
 			agentHost: { key: AgentMergeConfigKey.ReplyAttribution },
 		},
+		[ChatProvidersSettingId.Enabled]: {
+			type: 'boolean',
+			description: nls.localize('chat.agentHost.multipleChatProviders.enabled', "Enables chats in one Agent Host session to use different agents."),
+			default: false,
+			scope: ConfigurationScope.APPLICATION,
+			tags: ['experimental'],
+			agentHost: { key: ChatProvidersConfigKey.Enabled },
+		},
 		...chatMoveConfigurationProperties,
 		...titleGenerationConfigurationProperties,
 		...artifactToolsConfigurationProperties,