sessions: scope model and agent selection per chat (#323744)

Sessions - scope model and agent selection per chat

In the Agents window a session can contain multiple peer chats, and the
model/agent decision is meant to be per chat. The provider already wrote
the selection to the active chat, but `VisibleSession` (the
`IActiveSession` the pickers bind to) exposed the session/default chat's
`modelId`/`mode`, so every chat tab read and displayed the same
selection. Derive `modelId`/`mode` from the active chat so reads and
writes are both scoped to the focused chat.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: sandy081

src/vs/sessions/services/sessions/browser/visibleSessions.ts

@@ -32,6 +32,15 @@ export class VisibleSession extends Disposable implements IActiveSession {
 	private readonly _activeChat: ISettableObservable<IChat>;
 	readonly activeChat: IObservable<IChat>;
 
+	/**
+	 * Model and mode are scoped to the active chat so the Agents window pickers
+	 * read and write the selection of the currently focused chat, not the
+	 * session/default chat. Sessions with multiple peer chats keep an
+	 * independent model/agent per chat.
+	 */
+	private readonly _activeChatModelId: IObservable<string | undefined>;
+	private readonly _activeChatMode: IObservable<{ readonly id: string; readonly kind: string } | undefined>;
+
 	/** Resource strings of chats that have been closed (hidden from the tab strip). */
 	private readonly _closedChatUris: ISettableObservable<ReadonlySet<string>>;
 	readonly openChats: IObservable<readonly IChat[]>;
@@ -47,6 +56,9 @@ export class VisibleSession extends Disposable implements IActiveSession {
 		this._activeChat = observableValue<IChat>(`activeChat-${_session.sessionId}`, initialChat);
 		this.activeChat = this._activeChat;
 
+		this._activeChatModelId = derived(this, reader => this._activeChat.read(reader).modelId.read(reader));
+		this._activeChatMode = derived(this, reader => this._activeChat.read(reader).mode.read(reader));
+
 		// Seed the closed set from persisted state, but never hide the chat that
 		// is being restored as active, nor the main chat (which can never be
 		// closed and must always remain in the tab strip).
@@ -137,8 +149,8 @@ export class VisibleSession extends Disposable implements IActiveSession {
 	get status() { return this._session.status; }
 	get changes() { return this._session.changes; }
 	get changesets() { return this._session.changesets; }
-	get modelId() { return this._session.modelId; }
-	get mode() { return this._session.mode; }
+	get modelId() { return this._activeChatModelId; }
+	get mode() { return this._activeChatMode; }
 	get loading() { return this._session.loading; }
 	get isArchived() { return this._session.isArchived; }
 	get isRead() { return this._session.isRead; }

src/vs/sessions/services/sessions/test/browser/visibleSessions.test.ts

@@ -1055,3 +1055,38 @@ suite('VisibleSession - visibleChatTabs', () => {
 		assert.deepStrictEqual(visible.visibleChatTabs.get().map(c => c.title.get()), ['main', 'draft', 'second']);
 	});
 });
+
+suite('VisibleSession - per-chat model/mode', () => {
+
+	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
+
+	function makeChat(id: string, modelId: string | undefined, modeId: string | undefined): IChat {
+		return {
+			...stubChat,
+			resource: URI.parse(`test:///chat/${id}`),
+			title: constObservable(id),
+			modelId: constObservable(modelId),
+			mode: constObservable(modeId ? { id: modeId, kind: 'agent' } : undefined),
+		};
+	}
+
+	test('modelId and mode follow the active chat, not the session/default chat', () => {
+		const first = makeChat('first', 'model-1', 'agent-1');
+		const second = makeChat('second', 'model-2', 'agent-2');
+		const base = stubSession('S');
+		const session: ISession = { ...base, chats: constObservable([first, second]), mainChat: constObservable(first) };
+		const visible = disposables.add(new VisibleSession(session, first));
+
+		assert.deepStrictEqual(
+			{ modelId: visible.modelId.get(), mode: visible.mode.get() },
+			{ modelId: 'model-1', mode: { id: 'agent-1', kind: 'agent' } },
+		);
+
+		visible.setActiveChat(second);
+
+		assert.deepStrictEqual(
+			{ modelId: visible.modelId.get(), mode: visible.mode.get() },
+			{ modelId: 'model-2', mode: { id: 'agent-2', kind: 'agent' } },
+		);
+	});
+});