fix: align tool search with request snapshot

Co-authored-by: Copilot <copilot@github.com>

Author: PenguinDOOM

extensions/copilot/src/extension/tools/node/test/toolSearchTool.spec.ts

@@ -35,13 +35,6 @@ suite('ToolSearchTool', () => {
 					return tools.map(candidate => candidate.name);
 				},
 			} as any,
-			{
-				tools: [
-					makeToolInfo('read_file'),
-					makeToolInfo('enabled_deferred_tool'),
-					makeToolInfo('disabled_deferred_tool'),
-				],
-			} as any,
 			{
 				isNonDeferredTool: (name: string) => nonDeferred.has(name),
 			} as any,
@@ -81,13 +74,6 @@ suite('ToolSearchTool', () => {
 					return tools.map(candidate => candidate.name);
 				},
 			} as any,
-			{
-				tools: [
-					makeToolInfo('read_file'),
-					makeToolInfo('request_a_tool'),
-					makeToolInfo('request_b_tool'),
-				],
-			} as any,
 			{
 				isNonDeferredTool: (name: string) => nonDeferred.has(name),
 			} as any,
@@ -132,6 +118,45 @@ suite('ToolSearchTool', () => {
 		expect(searchedToolNames).toEqual([['request_a_tool']]);
 	});
 
+	test('retains request-scoped virtual activate groups during tool search candidate selection', async () => {
+		const searchedToolNames: string[][] = [];
+		const nonDeferred = new Set(['read_file']);
+		const tool = new ToolSearchTool(
+			{
+				searchToolsByQuery: async (_query: string, tools: readonly vscode.LanguageModelToolInformation[]) => {
+					searchedToolNames.push(tools.map(candidate => candidate.name));
+					return tools.map(candidate => candidate.name);
+				},
+			} as any,
+			{
+				isNonDeferredTool: (name: string) => nonDeferred.has(name),
+			} as any,
+			{ trace() { } } as any,
+		);
+
+		const resolvedInput = await (tool as any).resolveInput?.(
+			{ query: 'vscode interaction tools' },
+			{
+				tools: {
+					toolReferences: [],
+					toolInvocationToken: undefined as never,
+					availableTools: [
+						makeToolInfo('read_file'),
+						makeToolInfo('activate_vs_code_interaction'),
+					],
+				},
+			},
+			0,
+		);
+
+		await tool.invoke(
+			{ input: resolvedInput } as vscode.LanguageModelToolInvocationOptions<{ query: string }>,
+			{ isCancellationRequested: false } as vscode.CancellationToken,
+		);
+
+		expect(searchedToolNames).toEqual([['activate_vs_code_interaction']]);
+	});
+
 	test('fails explicitly when invoke runs without request-scoped resolveInput context', async () => {
 		const nonDeferred = new Set(['read_file']);
 		const tool = new ToolSearchTool(
@@ -140,11 +165,6 @@ suite('ToolSearchTool', () => {
 					throw new Error('search should not run without resolveInput context');
 				},
 			} as any,
-			{
-				tools: [
-					makeToolInfo('enabled_deferred_tool'),
-				],
-			} as any,
 			{
 				isNonDeferredTool: (name: string) => nonDeferred.has(name),
 			} as any,
@@ -156,6 +176,36 @@ suite('ToolSearchTool', () => {
 			{ isCancellationRequested: false } as vscode.CancellationToken,
 		)).rejects.toThrow('ToolSearchTool: request-scoped deferred tools are unavailable. Ensure resolveInput is called before invoke.');
 	});
+
+	test('uses an empty deferred tool snapshot when promptContext.tools is missing', async () => {
+		const searchedToolNames: string[][] = [];
+		const tool = new ToolSearchTool(
+			{
+				searchToolsByQuery: async (_query: string, tools: readonly vscode.LanguageModelToolInformation[]) => {
+					searchedToolNames.push(tools.map(candidate => candidate.name));
+					return tools.map(candidate => candidate.name);
+				},
+			} as any,
+			{
+				isNonDeferredTool: () => false,
+			} as any,
+			{ trace() { } } as any,
+		);
+
+		const resolvedInput = await tool.resolveInput(
+			{ query: 'anything' },
+			{} as any,
+			0,
+		);
+
+		const result = await tool.invoke(
+			{ input: resolvedInput } as vscode.LanguageModelToolInvocationOptions<{ query: string }>,
+			{ isCancellationRequested: false } as vscode.CancellationToken,
+		);
+
+		expect(searchedToolNames).toEqual([[]]);
+		expect(result.content).toEqual([expect.objectContaining({ value: '[]' })]);
+	});
 });
 
 suite('TestToolsService getEnabledTools', () => {

extensions/copilot/src/extension/tools/node/toolSearchTool.ts

@@ -12,7 +12,6 @@ import { LanguageModelTextPart, LanguageModelToolResult } from '../../../vscodeT
 import { IBuildPromptContext } from '../../prompt/common/intents';
 import { createRequestToolManifest } from '../common/requestToolManifest';
 import { CopilotToolMode, ICopilotModelSpecificTool, ToolRegistry } from '../common/toolsRegistry';
-import { IToolsService } from '../common/toolsService';
 import { IToolEmbeddingsComputer } from '../common/virtualTools/toolEmbeddingsComputer';
 
 export interface IToolSearchParams {
@@ -21,16 +20,15 @@ export interface IToolSearchParams {
 }
 
 const DEFAULT_SEARCH_LIMIT = 5;
-const requestScopedDeferredToolNamesKey = Symbol('requestScopedDeferredToolNames');
+const requestScopedDeferredToolsKey = Symbol('requestScopedDeferredTools');
 
 type ResolvedToolSearchParams = IToolSearchParams & {
-	[requestScopedDeferredToolNamesKey]?: readonly string[];
+	[requestScopedDeferredToolsKey]?: readonly vscode.LanguageModelToolInformation[];
 };
 
 export class ToolSearchTool implements ICopilotModelSpecificTool<IToolSearchParams> {
 	constructor(
 		@IToolEmbeddingsComputer private readonly _toolEmbeddingsComputer: IToolEmbeddingsComputer,
-		@IToolsService private readonly _toolsService: IToolsService,
 		@IToolDeferralService private readonly _toolDeferralService: IToolDeferralService,
 		@ILogService private readonly _logService: ILogService,
 	) { }
@@ -44,19 +42,15 @@ export class ToolSearchTool implements ICopilotModelSpecificTool<IToolSearchPara
 			]);
 		}
 
-		const requestScopedDeferredToolNames = (options.input as ResolvedToolSearchParams)[requestScopedDeferredToolNamesKey];
+		const requestScopedDeferredTools = (options.input as ResolvedToolSearchParams)[requestScopedDeferredToolsKey];
 
-		if (!requestScopedDeferredToolNames) {
+		if (!requestScopedDeferredTools) {
 			throw new Error('ToolSearchTool: request-scoped deferred tools are unavailable. Ensure resolveInput is called before invoke.');
 		}
 
-		const allowedToolNames = new Set(requestScopedDeferredToolNames);
-		const availableTools = createRequestToolManifest(this._toolsService.tools, this._toolDeferralService)
-			.deferredTools
-			.filter(tool => allowedToolNames.has(tool.name));
 		const matchedToolNames = await this._toolEmbeddingsComputer.searchToolsByQuery(
 			query,
-			availableTools,
+			requestScopedDeferredTools,
 			limit ?? DEFAULT_SEARCH_LIMIT,
 			token,
 		);
@@ -74,8 +68,8 @@ export class ToolSearchTool implements ICopilotModelSpecificTool<IToolSearchPara
 	async resolveInput(input: IToolSearchParams, promptContext: IBuildPromptContext, _mode: CopilotToolMode): Promise<IToolSearchParams> {
 		const manifest = createRequestToolManifest(promptContext.tools?.availableTools ?? [], this._toolDeferralService);
 		const resolvedInput: ResolvedToolSearchParams = { ...input };
-		Object.defineProperty(resolvedInput, requestScopedDeferredToolNamesKey, {
-			value: Object.freeze([...manifest.deferredToolNames]),
+		Object.defineProperty(resolvedInput, requestScopedDeferredToolsKey, {
+			value: Object.freeze([...manifest.deferredTools]),
 			enumerable: false,
 		});
 		return resolvedInput;