show model details in footer for claude harness (#313452)

* show model details in footer for claude harness

* address comments and refactor

* remove extra check

Author: justschen

extensions/copilot/src/extension/chatSessions/claude/node/claudeCodeModels.ts

@@ -113,16 +113,7 @@ export class ClaudeCodeModels extends Disposable implements IClaudeCodeModels {
 
 	public async resolveReasoningEffort(requestedModel: ParsedClaudeModelId | string | undefined, requestedReasoningEffort: string | undefined): Promise<EffortLevel | undefined> {
 		const endpoint = await this.resolveEndpoint(requestedModel, undefined);
-		if (!endpoint || !endpoint.supportsReasoningEffort || endpoint.supportsReasoningEffort.length === 0) {
-			return undefined;
-		}
-		if (requestedReasoningEffort && isEffortLevel(requestedReasoningEffort) && endpoint.supportsReasoningEffort.includes(requestedReasoningEffort)) {
-			return requestedReasoningEffort;
-		}
-		if (endpoint.supportsReasoningEffort.length === 1 && isEffortLevel(endpoint.supportsReasoningEffort[0])) {
-			return endpoint.supportsReasoningEffort[0];
-		}
-		return undefined;
+		return pickReasoningEffort(endpoint, requestedReasoningEffort);
 	}
 
 	public async resolveEndpoint(requestedModel: ParsedClaudeModelId | string | undefined, fallbackModelId: ParsedClaudeModelId | undefined): Promise<IChatEndpoint | undefined> {
@@ -199,6 +190,30 @@ export function isEffortLevel(value: string): value is EffortLevel {
 	return SUPPORTED_EFFORT_LEVELS.includes(value as EffortLevel);
 }
 
+/**
+ * Formats a Claude endpoint for display in the chat response footer.
+ * Mirrors the Codex CLI's `formatModelDetails` for visual parity across providers.
+ */
+export function formatClaudeModelDetails(endpoint: IChatEndpoint): string {
+	return `${endpoint.name}${endpoint.multiplier ? ` • ${endpoint.multiplier}x` : ''}`;
+}
+
+/**
+ * Picks the reasoning effort to use for an endpoint given a requested level.
+ */
+export function pickReasoningEffort(endpoint: IChatEndpoint | undefined, requestedReasoningEffort: string | undefined): EffortLevel | undefined {
+	if (!endpoint || !endpoint.supportsReasoningEffort || endpoint.supportsReasoningEffort.length === 0) {
+		return undefined;
+	}
+	if (requestedReasoningEffort && isEffortLevel(requestedReasoningEffort) && endpoint.supportsReasoningEffort.includes(requestedReasoningEffort)) {
+		return requestedReasoningEffort;
+	}
+	if (endpoint.supportsReasoningEffort.length === 1 && isEffortLevel(endpoint.supportsReasoningEffort[0])) {
+		return endpoint.supportsReasoningEffort[0];
+	}
+	return undefined;
+}
+
 function buildConfigurationSchema(endpoint: IChatEndpoint): vscode.LanguageModelConfigurationSchema | undefined {
 	const effortLevels = endpoint.supportsReasoningEffort?.filter(
 		(level): level is typeof SUPPORTED_EFFORT_LEVELS[number] =>

extensions/copilot/src/extension/chatSessions/vscode-node/chatHistoryBuilder.ts

@@ -381,8 +381,10 @@ function findModelIdForRequest(
  * when we encounter a user message with actual text (a new user request).
  *
  * @param session The Claude Code session to convert
+ * @param getModelDetails Optional lookup that returns the display string for a Claude
+ * model id (as it appears on stored assistant messages).
  */
-export function buildChatHistory(session: IClaudeCodeSession): (vscode.ChatRequestTurn2 | vscode.ChatResponseTurn2)[] {
+export function buildChatHistory(session: IClaudeCodeSession, getModelDetails?: (modelId: string) => string | undefined): (vscode.ChatRequestTurn2 | vscode.ChatResponseTurn2)[] {
 	const result: (vscode.ChatRequestTurn2 | vscode.ChatResponseTurn2)[] = [];
 	const toolContext: ToolContext = {
 		unprocessedToolCalls: new Map(),
@@ -391,6 +393,16 @@ export function buildChatHistory(session: IClaudeCodeSession): (vscode.ChatReque
 	let i = 0;
 	const messages = session.messages;
 	let pendingResponseParts: (vscode.ChatResponseMarkdownPart | vscode.ChatResponseThinkingProgressPart | vscode.ChatToolInvocationPart)[] = [];
+	// Tracks the most recent assistant model id observed in the current pending response
+	// group so we can populate `ChatResponseTurn2.result.details` when finalizing it.
+	let pendingResponseModelId: string | undefined;
+	const makeResponseResult = (modelId: string | undefined): vscode.ChatResult => {
+		if (!modelId || !getModelDetails) {
+			return {};
+		}
+		const details = getModelDetails(modelId);
+		return details ? { details } : {};
+	};
 
 	// Build a map from parentToolUseId to subagent for quick lookup
 	const subagentMap = buildSubagentMap(session.subagents);
@@ -437,8 +449,9 @@ export function buildChatHistory(session: IClaudeCodeSession): (vscode.ChatReque
 			if (commandInfo) {
 				// Finalize any pending response first
 				if (pendingResponseParts.length > 0) {
-					result.push(new vscode.ChatResponseTurn2(pendingResponseParts, {}, ''));
+					result.push(new vscode.ChatResponseTurn2(pendingResponseParts, makeResponseResult(pendingResponseModelId), ''));
 					pendingResponseParts = [];
+					pendingResponseModelId = undefined;
 				}
 				// Emit the command as a request turn
 				result.push(new ChatRequestTurn2(commandInfo.commandName, undefined, [], '', [], undefined, currentMessageId, modelId, undefined));
@@ -456,8 +469,9 @@ export function buildChatHistory(session: IClaudeCodeSession): (vscode.ChatReque
 				if (requestTurn) {
 					// Real user message — finalize any pending response first
 					if (pendingResponseParts.length > 0) {
-						result.push(new vscode.ChatResponseTurn2(pendingResponseParts, {}, ''));
+						result.push(new vscode.ChatResponseTurn2(pendingResponseParts, makeResponseResult(pendingResponseModelId), ''));
 						pendingResponseParts = [];
+						pendingResponseModelId = undefined;
 					}
 					result.push(requestTurn);
 				}
@@ -471,6 +485,9 @@ export function buildChatHistory(session: IClaudeCodeSession): (vscode.ChatReque
 				const assistantMessage = messages[i].message as AssistantMessageContent;
 				if (assistantMessage.model !== SYNTHETIC_MODEL_ID) {
 					assistantMessages.push(assistantMessage);
+					if (assistantMessage.model) {
+						pendingResponseModelId = assistantMessage.model;
+					}
 				}
 				i++;
 			}
@@ -500,7 +517,7 @@ export function buildChatHistory(session: IClaudeCodeSession): (vscode.ChatReque
 
 	// Finalize any remaining pending response
 	if (pendingResponseParts.length > 0) {
-		result.push(new vscode.ChatResponseTurn2(pendingResponseParts, {}, ''));
+		result.push(new vscode.ChatResponseTurn2(pendingResponseParts, makeResponseResult(pendingResponseModelId), ''));
 	}
 
 	return result;

extensions/copilot/src/extension/chatSessions/vscode-node/claudeChatSessionContentProvider.ts

@@ -10,6 +10,7 @@ import { ConfigKey, IConfigurationService } from '../../../platform/configuratio
 import { INativeEnvService } from '../../../platform/env/common/envService';
 import { getGitHubRepoInfoFromContext, IGitService } from '../../../platform/git/common/gitService';
 import { ILogService } from '../../../platform/log/common/logService';
+import { IChatEndpoint } from '../../../platform/networking/common/networking';
 import { IWorkspaceService } from '../../../platform/workspace/common/workspaceService';
 import { CancellationToken } from '../../../util/vs/base/common/cancellation';
 import { Emitter, Event } from '../../../util/vs/base/common/event';
@@ -22,12 +23,12 @@ import { IInstantiationService } from '../../../util/vs/platform/instantiation/c
 import { ClaudeFolderInfo } from '../claude/common/claudeFolderInfo';
 import { ClaudeSessionUri } from '../claude/common/claudeSessionUri';
 import { ClaudeAgentManager } from '../claude/node/claudeCodeAgent';
-import { CLAUDE_REASONING_EFFORT_PROPERTY, IClaudeCodeModels } from '../claude/node/claudeCodeModels';
+import { CLAUDE_REASONING_EFFORT_PROPERTY, formatClaudeModelDetails, IClaudeCodeModels, pickReasoningEffort } from '../claude/node/claudeCodeModels';
 import { IClaudeCodeSdkService } from '../claude/node/claudeCodeSdkService';
 import { parseClaudeModelId } from '../claude/node/claudeModelId';
 import { IClaudeSessionStateService } from '../claude/common/claudeSessionStateService';
 import { IClaudeCodeSessionService } from '../claude/node/sessionParser/claudeCodeSessionService';
-import { IClaudeCodeSessionInfo } from '../claude/node/sessionParser/claudeSessionSchema';
+import { IClaudeCodeSessionInfo, IClaudeCodeSession, SYNTHETIC_MODEL_ID } from '../claude/node/sessionParser/claudeSessionSchema';
 import { IClaudeSlashCommandService } from '../claude/vscode-node/claudeSlashCommandService';
 import { IChatFolderMruService } from '../common/folderRepositoryManager';
 import { builtinSlashCommands } from '../common/builtinSlashCommands';
@@ -139,8 +140,13 @@ export class ClaudeChatSessionContentProvider extends Disposable implements vsco
 			this.sessionStateService.setPermissionModeForSession(effectiveSessionId, permissionMode);
 			this.sessionStateService.setFolderInfoForSession(effectiveSessionId, folderInfo);
 
+			// Resolve the endpoint once and reuse it for both reasoning effort
+			// and the response footer details — they otherwise both call
+			// `resolveEndpoint` (which hits the cached endpoint list, then
+			// re-filters), which is wasted work and risks divergence.
+			const endpoint = await this._resolveEndpointForRequest(modelId.toEndpointModelId());
 			const rawReasoningEffort = request.modelConfiguration?.[CLAUDE_REASONING_EFFORT_PROPERTY];
-			const reasoningEffort = await this.claudeModels.resolveReasoningEffort(modelId, rawReasoningEffort);
+			const reasoningEffort = pickReasoningEffort(endpoint, typeof rawReasoningEffort === 'string' ? rawReasoningEffort : undefined);
 			this.sessionStateService.setReasoningEffortForSession(effectiveSessionId, reasoningEffort);
 
 			// Set usage handler to report token usage for context window widget
@@ -156,16 +162,21 @@ export class ClaudeChatSessionContentProvider extends Disposable implements vsco
 			// Clear usage handler after request completes
 			this.sessionStateService.setUsageHandlerForSession(effectiveSessionId, undefined);
 
-			return result.errorDetails ? { errorDetails: result.errorDetails } : {};
+			const details = endpoint ? formatClaudeModelDetails(endpoint) : undefined;
+			return {
+				...(details ? { details } : {}),
+				...(result.errorDetails ? { errorDetails: result.errorDetails } : {}),
+			};
 		};
 	}
 
 	// #endregion
 
 	async provideChatSessionContent(sessionResource: vscode.Uri, token: vscode.CancellationToken, context?: { readonly inputState: vscode.ChatSessionInputState }): Promise<vscode.ChatSession> {
 		const existingSession = await this.sessionService.getSession(sessionResource, token);
+		const detailsByModelId = existingSession ? await this._buildModelDetailsLookup(existingSession, token) : undefined;
 		const history = existingSession ?
-			buildChatHistory(existingSession) :
+			buildChatHistory(existingSession, detailsByModelId ? id => detailsByModelId.get(id) : undefined) :
 			[];
 
 		const options: Record<string, string | vscode.ChatSessionProviderOptionItem> = {};
@@ -188,6 +199,57 @@ export class ClaudeChatSessionContentProvider extends Disposable implements vsco
 			options,
 		};
 	}
+
+	/**
+	 * Resolves a Claude model id to its endpoint. Wraps `resolveEndpoint` in a
+	 * try/catch so transient failures degrade gracefully (return `undefined`)
+	 * instead of breaking the response or session-load path.
+	 */
+	private async _resolveEndpointForRequest(modelId: string): Promise<IChatEndpoint | undefined> {
+		try {
+			return await this.claudeModels.resolveEndpoint(modelId, undefined);
+		} catch {
+			return undefined;
+		}
+	}
+
+	/**
+	 * Resolves the display string for each unique non-synthetic model id observed in the
+	 * session's assistant messages. Returns `undefined` (not an empty map) when no model
+	 * ids are present, when the caller has cancelled, or when no ids resolve to known
+	 * endpoints — so callers can skip the per-turn details work entirely.
+	 */
+	private async _buildModelDetailsLookup(session: IClaudeCodeSession, token: vscode.CancellationToken): Promise<Map<string, string> | undefined> {
+		if (token.isCancellationRequested) {
+			return undefined;
+		}
+		const modelIds = new Set<string>();
+		for (const msg of session.messages) {
+			if (msg.type === 'assistant' && msg.message.role === 'assistant') {
+				const model = msg.message.model;
+				if (model && model !== SYNTHETIC_MODEL_ID) {
+					modelIds.add(model);
+				}
+			}
+		}
+		if (modelIds.size === 0) {
+			return undefined;
+		}
+		const detailsByModelId = new Map<string, string>();
+		await Promise.all([...modelIds].map(async modelId => {
+			if (token.isCancellationRequested) {
+				return;
+			}
+			const endpoint = await this._resolveEndpointForRequest(modelId);
+			if (endpoint) {
+				detailsByModelId.set(modelId, formatClaudeModelDetails(endpoint));
+			}
+		}));
+		if (token.isCancellationRequested) {
+			return undefined;
+		}
+		return detailsByModelId.size > 0 ? detailsByModelId : undefined;
+	}
 }
 
 /**

extensions/copilot/src/extension/chatSessions/vscode-node/test/chatHistoryBuilder.spec.ts

@@ -1390,4 +1390,125 @@ describe('buildChatHistory', () => {
 	});
 
 	// #endregion
+
+	// #region Response Details (model footer)
+
+	describe('response details via getModelDetails', () => {
+		// Returns the raw model id back so we can spot-check exactly which id the
+		// builder fed into the lookup for each response turn.
+		const echoLookup = (id: string) => `details:${id}`;
+
+		it('omits details when no lookup is provided (regression)', () => {
+			const s = session([
+				userMsg('Hello'),
+				assistantMsg([{ type: 'text', text: 'Hi' }], 'claude-opus-4-5-20251101'),
+			]);
+
+			const result = buildChatHistory(s);
+
+			const responseTurn = result[1] as vscode.ChatResponseTurn2;
+			expect(responseTurn.result).toEqual({});
+		});
+
+		it('attaches details from the assistant model id to the response turn', () => {
+			const s = session([
+				userMsg('Hello'),
+				assistantMsg([{ type: 'text', text: 'Hi' }], 'claude-opus-4-5-20251101'),
+			]);
+
+			const result = buildChatHistory(s, echoLookup);
+
+			const responseTurn = result[1] as vscode.ChatResponseTurn2;
+			expect(responseTurn.result).toEqual({ details: 'details:claude-opus-4-5-20251101' });
+		});
+
+		it('omits details when the lookup returns undefined', () => {
+			const s = session([
+				userMsg('Hello'),
+				assistantMsg([{ type: 'text', text: 'Hi' }], 'unknown-model-id'),
+			]);
+
+			const result = buildChatHistory(s, () => undefined);
+
+			const responseTurn = result[1] as vscode.ChatResponseTurn2;
+			expect(responseTurn.result).toEqual({});
+		});
+
+		it('attributes per-response model details across model switches', () => {
+			const s = session([
+				userMsg('First'),
+				assistantMsg([{ type: 'text', text: 'A1' }], 'claude-sonnet-4-20250514'),
+				userMsg('Second'),
+				assistantMsg([{ type: 'text', text: 'A2' }], 'claude-opus-4-5-20251101'),
+			]);
+
+			const result = buildChatHistory(s, echoLookup);
+
+			const firstResponse = result[1] as vscode.ChatResponseTurn2;
+			const secondResponse = result[3] as vscode.ChatResponseTurn2;
+			expect(firstResponse.result).toEqual({ details: 'details:claude-sonnet-4-20250514' });
+			expect(secondResponse.result).toEqual({ details: 'details:claude-opus-4-5-20251101' });
+		});
+
+		it('uses the last non-synthetic assistant model in a multi-message response group', () => {
+			const s = session([
+				userMsg('Run'),
+				assistantMsg([{ type: 'tool_use', id: 't1', name: 'bash', input: {} }], 'claude-sonnet-4-20250514'),
+				toolResult('t1', 'done'),
+				// Final assistant message uses a different model — that's the one we attribute.
+				assistantMsg([{ type: 'text', text: 'OK' }], 'claude-opus-4-5-20251101'),
+			]);
+
+			const result = buildChatHistory(s, echoLookup);
+
+			const responseTurn = result[1] as vscode.ChatResponseTurn2;
+			expect(responseTurn.result).toEqual({ details: 'details:claude-opus-4-5-20251101' });
+		});
+
+		it('does not bleed model ids across response groups when lookup is undefined for one', () => {
+			const s = session([
+				userMsg('First'),
+				assistantMsg([{ type: 'text', text: 'A1' }], 'claude-sonnet-4-20250514'),
+				userMsg('Second'),
+				assistantMsg([{ type: 'text', text: 'A2' }], 'unknown-model-id'),
+			]);
+
+			const result = buildChatHistory(s, id => id === 'claude-sonnet-4-20250514' ? 'Sonnet' : undefined);
+
+			const firstResponse = result[1] as vscode.ChatResponseTurn2;
+			const secondResponse = result[3] as vscode.ChatResponseTurn2;
+			expect(firstResponse.result).toEqual({ details: 'Sonnet' });
+			expect(secondResponse.result).toEqual({});
+		});
+
+		it('ignores synthetic assistant messages when picking the response model id', () => {
+			const s = session([
+				userMsg('Hello'),
+				assistantMsg([{ type: 'text', text: 'Real reply' }], 'claude-sonnet-4-20250514'),
+				// A trailing synthetic message (e.g. cancellation marker) must not
+				// override the real model id we just observed.
+				assistantMsg([{ type: 'text', text: 'No response requested.' }], SYNTHETIC_MODEL_ID),
+			]);
+
+			const result = buildChatHistory(s, echoLookup);
+
+			const responseTurn = result[1] as vscode.ChatResponseTurn2;
+			expect(responseTurn.result).toEqual({ details: 'details:claude-sonnet-4-20250514' });
+		});
+
+		it('attaches details to slash-command response turns', () => {
+			const s = session([
+				userMsg('<command-name>/compact</command-name><command-message>compact</command-message>'),
+				assistantMsg([{ type: 'text', text: 'Compacted.' }], 'claude-sonnet-4-20250514'),
+			]);
+
+			const result = buildChatHistory(s, echoLookup);
+
+			// [request, response]
+			const responseTurn = result[1] as vscode.ChatResponseTurn2;
+			expect(responseTurn.result).toEqual({ details: 'details:claude-sonnet-4-20250514' });
+		});
+	});
+
+	// #endregion
 });