[release/1.118] On agent mode change, ignore stateful marker (#313071)

* on agent mode change, ignore stateful marker

* updates to modechange

Author: dileepyavan

extensions/copilot/src/extension/agents/vscode-node/test/planAgentProvider.spec.ts

@@ -18,7 +18,7 @@ import { DisposableStore } from '../../../../util/vs/base/common/lifecycle';
 import { SyncDescriptor } from '../../../../util/vs/platform/instantiation/common/descriptors';
 import { IInstantiationService } from '../../../../util/vs/platform/instantiation/common/instantiation';
 import { createExtensionUnitTestingServices } from '../../../test/node/services';
-import { buildAgentMarkdown } from '../agentTypes';
+import { buildAgentMarkdown, DEFAULT_READ_TOOLS } from '../agentTypes';
 import { PlanAgentProvider } from '../planAgentProvider';
 
 suite('PlanAgentProvider', () => {
@@ -249,6 +249,24 @@ suite('PlanAgentProvider', () => {
 		assert.ok(content.includes('vscode/askQuestions'));
 	});
 
+	test('exposes only default read tools plus agent and askQuestions in plan mode by default', async () => {
+		const provider = createProvider();
+		const agents = await provider.provideCustomAgents({}, {} as any);
+
+		assert.equal(agents.length, 1);
+		const content = await getAgentContent(agents[0]);
+
+		const toolsMatch = content.match(/tools: \[([^\]]+)\]/);
+		assert.ok(toolsMatch, 'Tools list not found in agent content');
+		const actualTools = (toolsMatch[1].match(/'([^']+)'/g) || []).map(tool => tool.slice(1, -1)).sort();
+		const expectedTools = [...DEFAULT_READ_TOOLS, 'agent', 'vscode/askQuestions'].sort();
+
+		assert.deepStrictEqual(actualTools, expectedTools);
+		assert.ok(!actualTools.includes('edit'));
+		assert.ok(!actualTools.includes('createFile'));
+		assert.ok(!actualTools.includes('apply_patch'));
+	});
+
 	test('has correct label property', () => {
 		const provider = createProvider();
 		assert.ok(provider.label.includes('Plan'));

extensions/copilot/src/extension/intents/node/editCodeIntent.ts

@@ -123,7 +123,7 @@ export class EditCodeIntent implements IIntent {
 				const { references } = await renderPromptElement(this.instantiationService, endpoint, ToolCallResultWrapper, { toolCallResults }, undefined, token);
 				foundReferences.push(...toNewChatReferences(variables, references));
 				// TODO: how should we splice in the assistant message?
-				conversation = new Conversation(conversation.sessionId, [...conversation.turns.slice(0, -1), new Turn(latestTurn.id, latestTurn.request, undefined)]);
+				conversation = new Conversation(conversation.sessionId, [...conversation.turns.slice(0, -1), new Turn(latestTurn.id, latestTurn.request, undefined, [], undefined, undefined, false, latestTurn.modeInstructions)]);
 			}
 			return { conversation, request: { ...request, references: [...request.references, ...foundReferences], toolReferences: request.toolReferences.filter((r) => r.name !== CodebaseTool.toolName) } };
 		}

extensions/copilot/src/extension/intents/node/toolCallingLoop.ts

@@ -192,6 +192,10 @@ export abstract class ToolCallingLoop<TOptions extends IToolCallingLoopOptions =
 	private readonly _onDidReceiveResponse = this._register(new Emitter<IToolCallingResponseEvent>());
 	public readonly onDidReceiveResponse = this._onDidReceiveResponse.event;
 
+	protected get currentToolCallRounds(): readonly IToolCallRound[] {
+		return this.toolCallRounds;
+	}
+
 	private get turn() {
 		return this.options.conversation.getLatestTurn();
 	}

extensions/copilot/src/extension/prompt/common/conversation.ts

@@ -80,6 +80,7 @@ export class Turn {
 			request.editedFileEvents,
 			request.acceptedConfirmationData,
 			isToolCallLimitAcceptance(request) || isContinueOnError(request) || isSwitchToAutoOnRateLimit(request),
+			request.modeInstructions2,
 		);
 	}
 
@@ -90,7 +91,8 @@ export class Turn {
 		private readonly _toolReferences: readonly InternalToolReference[] = [],
 		readonly editedFileEvents?: ChatRequestEditedFileEvent[],
 		readonly acceptedConfirmationData?: unknown[],
-		readonly isContinuation = false
+		readonly isContinuation = false,
+		readonly modeInstructions?: ChatRequest['modeInstructions2'],
 	) { }
 
 	get promptVariables(): ChatVariablesCollection | undefined {

extensions/copilot/src/extension/prompt/node/chatParticipantRequestHandler.ts

@@ -395,7 +395,10 @@ function createTurnFromVSCodeChatHistoryTurns(
 		{ message: chatRequestTurn.prompt, type: 'user' },
 		new ChatVariablesCollection(chatRequestTurn.references),
 		chatRequestTurn.toolReferences.map(InternalToolReference.from),
-		chatRequestAsTurn2.editedFileEvents
+		chatRequestAsTurn2.editedFileEvents,
+		undefined,
+		false,
+		chatRequestAsTurn2.modeInstructions2,
 	);
 
 	// Take just the content messages

extensions/copilot/src/extension/prompt/node/defaultIntentRequestHandler.ts

@@ -695,8 +695,10 @@ class DefaultToolCallingLoop extends ToolCallingLoop<IDefaultToolLoopOptions> {
 		const rawEffort = this.options.request.modelConfiguration?.reasoningEffort;
 		const reasoningEffort = typeof rawEffort === 'string' ? rawEffort : undefined;
 		const isSubagent = !!this.options.request.subAgentInvocationId;
+		const modeChanged = this.didModeChangeSincePreviousRequest();
 		return this.options.invocation.endpoint.makeChatRequest2({
 			...opts,
+			modeChanged,
 			modelCapabilities: {
 				...opts.modelCapabilities,
 				enableThinking: isThinkingLocation && opts.modelCapabilities?.enableThinking,
@@ -737,6 +739,36 @@ class DefaultToolCallingLoop extends ToolCallingLoop<IDefaultToolLoopOptions> {
 		}, token);
 	}
 
+	private didModeChangeSincePreviousRequest(): boolean {
+		if (this.options.invocation.endpoint.apiType !== 'responses') {
+			return false;
+		}
+
+		// Once a mode-switched turn has successfully produced a fresh responses-api
+		// stateful marker, later requests in the same turn should resume from that
+		// new chain instead of continuing to invalidate previous_response_id.
+		// This is especially important for websocket follow-up requests after tool
+		// calls: keeping modeChanged=true for the entire turn would force the full
+		// pre-switch history back into every follow-up request, which can pull the
+		// model back toward the prior mode (for example implementation after
+		// switching into Plan mode).
+		if (this.currentToolCallRounds.some(round => !!round.statefulMarker)) {
+			return false;
+		}
+
+		const previousModeInstructions = this.options.conversation.turns.at(-2)?.modeInstructions;
+		if (!previousModeInstructions && !this.options.request.modeInstructions2) {
+			return false;
+		}
+
+		const modeChanged = !areModeInstructionsEqual(previousModeInstructions, this.options.request.modeInstructions2);
+		if (modeChanged) {
+			this._logService.trace('[DefaultIntentRequestHandler] Detected mode instructions changed between requests');
+		}
+
+		return modeChanged;
+	}
+
 	protected override async getAvailableTools(outputStream: ChatResponseStream | undefined, token: CancellationToken): Promise<LanguageModelToolInformation[]> {
 		const tools = await this.options.invocation.getAvailableTools?.() ?? [];
 
@@ -793,3 +825,39 @@ class DefaultToolCallingLoop extends ToolCallingLoop<IDefaultToolLoopOptions> {
 interface IInternalRequestResult extends IToolCallLoopResult {
 	lastRequestTelemetry: ChatTelemetry;
 }
+
+type ModeInstructions = NonNullable<ChatRequest['modeInstructions2']>;
+type ModeInstructionMetadata = ModeInstructions['metadata'];
+
+function areModeInstructionsEqual(a: ChatRequest['modeInstructions2'], b: ChatRequest['modeInstructions2']): boolean {
+	if (!a || !b) {
+		return a === b;
+	}
+
+	return a.uri?.toString() === b.uri?.toString()
+		&& a.name === b.name
+		&& a.content === b.content
+		&& a.isBuiltin === b.isBuiltin
+		&& serializeModeInstructionMetadata(a.metadata) === serializeModeInstructionMetadata(b.metadata);
+}
+
+function normalizeModeInstructionMetadata(metadata: ModeInstructionMetadata): Record<string, boolean | string | number> | undefined {
+	if (!metadata) {
+		return undefined;
+	}
+
+	const entries = Object.entries(metadata).sort(([left], [right]) => left.localeCompare(right));
+	if (entries.length === 0) {
+		return undefined;
+	}
+
+	return entries.reduce<Record<string, boolean | string | number>>((result, [key, value]) => {
+		result[key] = value;
+		return result;
+	}, {});
+}
+
+function serializeModeInstructionMetadata(metadata: ModeInstructionMetadata): string | undefined {
+	const normalizedMetadata = normalizeModeInstructionMetadata(metadata);
+	return normalizedMetadata ? JSON.stringify(normalizedMetadata) : undefined;
+}

extensions/copilot/src/extension/prompt/node/test/defaultIntentRequestHandler.spec.ts

@@ -204,6 +204,46 @@ suite('defaultIntentRequestHandler', () => {
 		expect(result.metadata?.resolvedModel).toBe('gpt-4o-resolved');
 	});
 
+	test('ignores stateful marker when mode instructions changed on responses api requests', async () => {
+		const request = new TestChatRequest();
+		(request as any).modeInstructions2 = { name: 'Agent', content: 'agent instructions', isBuiltin: true };
+		(endpoint as any).apiType = 'responses';
+		const requestSpy = vi.spyOn(endpoint, 'makeChatRequest2');
+		const previousTurn = new Turn(generateUuid(), { message: 'previous', type: 'user' }, undefined, [], undefined, undefined, false, { name: 'Plan', content: 'plan instructions', isBuiltin: true } as any);
+		const handler = makeHandler({ request, turns: [previousTurn] });
+		chatResponse[0] = 'some response here :)';
+		promptResult = {
+			...nullRenderPromptResult(),
+			messages: [{ role: Raw.ChatRole.User, content: [toTextPart('hello world!')] }],
+		};
+
+		await handler.getResult();
+
+		expect(requestSpy).toHaveBeenCalledOnce();
+		expect(requestSpy.mock.calls[0][0].modeChanged).toBe(true);
+		expect(requestSpy.mock.calls[0][0].ignoreStatefulMarker).toBeUndefined();
+	});
+
+	test('preserves default stateful marker behavior when mode instructions are unchanged on responses api requests', async () => {
+		const request = new TestChatRequest();
+		(request as any).modeInstructions2 = { name: 'Agent', content: 'agent instructions', isBuiltin: true };
+		(endpoint as any).apiType = 'responses';
+		const requestSpy = vi.spyOn(endpoint, 'makeChatRequest2');
+		const previousTurn = new Turn(generateUuid(), { message: 'previous', type: 'user' }, undefined, [], undefined, undefined, false, { name: 'Agent', content: 'agent instructions', isBuiltin: true } as any);
+		const handler = makeHandler({ request, turns: [previousTurn] });
+		chatResponse[0] = 'some response here :)';
+		promptResult = {
+			...nullRenderPromptResult(),
+			messages: [{ role: Raw.ChatRole.User, content: [toTextPart('hello world!')] }],
+		};
+
+		await handler.getResult();
+
+		expect(requestSpy).toHaveBeenCalledOnce();
+		expect(requestSpy.mock.calls[0][0].modeChanged).toBe(false);
+		expect(requestSpy.mock.calls[0][0].ignoreStatefulMarker).toBeUndefined();
+	});
+
 	test('makes a tool call turn', async () => {
 		const handler = makeHandler();
 		chatResponse[0] = [{

extensions/copilot/src/platform/endpoint/node/responsesApi.ts

@@ -57,6 +57,7 @@ export function createResponsesRequestBody(accessor: ServicesAccessor, options:
 	// undefined if the connection is new or the summary state changed). Never fall
 	// back to the HTTP marker lookup in that case.
 	const ignoreStatefulMarker = !!options.ignoreStatefulMarker || !!options.useWebSocket;
+	const modeChanged = !!options.modeChanged;
 
 	// Tool search: when enabled, split tools into non-deferred (included in the request) and deferred
 	// (excluded from the request entirely). Uses OpenAI's client-executed tool search protocol: we add
@@ -124,7 +125,7 @@ export function createResponsesRequestBody(accessor: ServicesAccessor, options:
 
 	const body: IEndpointBody = {
 		model,
-		...rawMessagesToResponseAPI(model, options.messages, ignoreStatefulMarker, webSocketStatefulMarker, toolsMap),
+		...rawMessagesToResponseAPI(model, options.messages, ignoreStatefulMarker, webSocketStatefulMarker, toolsMap, modeChanged),
 		stream: true,
 		tools: finalTools.length > 0 ? finalTools : undefined,
 		// Only a subset of completion post options are supported, and some
@@ -290,7 +291,7 @@ function resolveWebSocketStatefulMarker(accessor: ServicesAccessor, options: ICr
 	return wsManager.getStatefulMarker(options.conversationId);
 }
 
-function rawMessagesToResponseAPI(modelId: string, messages: readonly Raw.ChatMessage[], ignoreStatefulMarker: boolean, webSocketStatefulMarker: string | undefined, toolsMap?: Map<string, OpenAiFunctionTool>): { input: OpenAI.Responses.ResponseInputItem[]; previous_response_id?: string } {
+function rawMessagesToResponseAPI(modelId: string, messages: readonly Raw.ChatMessage[], ignoreStatefulMarker: boolean, webSocketStatefulMarker: string | undefined, toolsMap?: Map<string, OpenAiFunctionTool>, modeChanged: boolean = false): { input: OpenAI.Responses.ResponseInputItem[]; previous_response_id?: string } {
 	const latestCompactionMessageIndex = getLatestCompactionMessageIndex(messages);
 	const latestCompactionMessage = latestCompactionMessageIndex !== undefined ? createCompactionRoundTripMessage(messages[latestCompactionMessageIndex]) : undefined;
 
@@ -312,6 +313,11 @@ function rawMessagesToResponseAPI(modelId: string, messages: readonly Raw.ChatMe
 		}
 	}
 
+	if (modeChanged) {
+		previousResponseId = undefined;
+		markerIndex = undefined;
+	}
+
 	if (markerIndex !== undefined) {
 		// Requests that resume from previous_response_id send only post-marker history,
 		// but they still need the latest compaction item even when that item predates