adding first pass at implementation

Author: 24anisha

extensions/copilot/package.json

@@ -4660,6 +4660,16 @@
 							"onExp"
 						]
 					},
+					"github.copilot.chat.searchSubagent.thoroughnessEnabled": {
+						"type": "boolean",
+						"default": false,
+						"markdownDescription": "%github.copilot.config.searchSubagent.thoroughnessEnabled%",
+						"tags": [
+							"advanced",
+							"experimental",
+							"onExp"
+						]
+					},
 					"github.copilot.chat.agentDebugLog.enabled": {
 						"type": "boolean",
 						"default": false,

extensions/copilot/package.nls.json

@@ -482,6 +482,7 @@
 	"github.copilot.config.searchSubagent.useAgenticProxy": "Use the agentic proxy for the search subagent tool.",
 	"github.copilot.config.searchSubagent.model": "Model to use for the search subagent. When useAgenticProxy is enabled, defaults to 'agentic-search-v3'. Otherwise defaults to the main agent model.",
 	"github.copilot.config.searchSubagent.toolCallLimit": "Maximum number of tool calls the search subagent can make during exploration.",
+	"github.copilot.config.searchSubagent.thoroughnessEnabled": "Enable the thoroughness parameter on the search subagent tool. When enabled, the caller can pass 'quick', 'medium', or 'thorough' to adjust the number of allowed tool-call turns (0.5×, 1×, or 2× the base toolCallLimit respectively).",
 	"copilot.tools.executionSubagent.name": "Execution Subagent",
 	"copilot.tools.executionSubagent.description": "Launch an execution-focused subagent that runs one or more terminal commands to accomplish a task. It is designed to select an efficient summary of the terminal outputs to return to the main agent context.",
 	"github.copilot.config.executionSubagent.enabled": "Enable the Execution Subagent tool in Copilot Chat. The Execution Subagent is designed to run terminal commands to accomplish an execution-based task.",

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

@@ -37,6 +37,8 @@ export interface ISearchSubagentToolCallingLoopOptions extends IToolCallingLoopO
 	subAgentInvocationId?: string;
 	/** The tool_call_id from the parent agent's LLM response that triggered this subagent invocation. */
 	parentToolCallId?: string;
+	/** Thoroughness level for the search, passed through to the prompt when thoroughnessEnabled config is on. */
+	thoroughness?: 'quick' | 'medium' | 'thorough';
 }
 
 export class SearchSubagentToolCallingLoop extends ToolCallingLoop<ISearchSubagentToolCallingLoopOptions> {
@@ -109,14 +111,16 @@ export class SearchSubagentToolCallingLoop extends ToolCallingLoop<ISearchSubage
 
 	protected async buildPrompt(buildPromptContext: IBuildPromptContext, progress: Progress<ChatResponseReferencePart | ChatResponseProgressPart>, token: CancellationToken): Promise<IBuildPromptResult> {
 		const endpoint = await this.getEndpoint();
-		const maxSearchTurns = this._configurationService.getExperimentBasedConfig(ConfigKey.Advanced.SearchSubagentToolCallLimit, this._experimentationService);
+		// Use the effective tool call limit from options (already adjusted for thoroughness in the tool)
+		const maxSearchTurns = this.options.toolCallLimit;
 		const renderer = PromptRenderer.create(
 			this.instantiationService,
 			endpoint,
 			SearchSubagentPrompt,
 			{
 				promptContext: buildPromptContext,
-				maxSearchTurns
+				maxSearchTurns,
+				thoroughness: this.options.thoroughness,
 			}
 		);
 		return await renderer.render(progress, token);

extensions/copilot/src/extension/prompts/node/agent/searchSubagentPrompt.tsx

@@ -11,8 +11,16 @@ import { ChatToolCalls } from '../panel/toolCalling';
 
 export interface SearchSubagentPromptProps extends GenericBasePromptElementProps {
 	readonly maxSearchTurns: number;
+	/** Thoroughness level requested by the caller. Influences the speed vs. thoroughness guidance in the system prompt. */
+	readonly thoroughness?: 'quick' | 'medium' | 'thorough';
 }
 
+const THOROUGHNESS_GUIDANCE: Record<NonNullable<SearchSubagentPromptProps['thoroughness']>, string> = {
+	quick: 'Prioritize speed: parallelize as many tool calls as possible, stop as soon as you have a reasonable answer, and avoid deep file reads unless strictly necessary.',
+	medium: 'Use a balanced approach: parallelize where possible and stop when you have sufficient context.',
+	thorough: 'Be exhaustive: explore all plausible leads, read deeper into files, and verify findings before concluding.',
+};
+
 /**
  * Prompt for the search subagent that uses custom search instructions
  * instead of the default agent system prompt.
@@ -28,12 +36,15 @@ export class SearchSubagentPrompt extends PromptElement<SearchSubagentPromptProp
 		const currentTurn = toolCallRounds?.length ?? 0;
 		const isLastTurn = currentTurn >= this.props.maxSearchTurns - 1;
 
+		const thoroughnessGuidance = this.props.thoroughness ? THOROUGHNESS_GUIDANCE[this.props.thoroughness] : undefined;
+
 		return (
 			<>
 				<SystemMessage priority={1000}>
 					You are an AI coding research assistant that uses search tools to gather information. You can call tools to search for information and read files across a codebase.<br />
 					<br />
-					Once you have thoroughly searched the repository, return a message with ONLY: the &lt;final_answer&gt; tag to provide paths and line ranges of relevant code snippets.<br />
+					{thoroughnessGuidance && (<>{thoroughnessGuidance}<br /><br /></>)}
+					Once you have searched the repository, return a message with ONLY: the &lt;final_answer&gt; tag to provide paths and line ranges of relevant code snippets.<br />
 					<br />
 					Example:<br />
 					<br />
@@ -59,4 +70,4 @@ export class SearchSubagentPrompt extends PromptElement<SearchSubagentPromptProp
 			</>
 		);
 	}
-}
+}

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

@@ -32,6 +32,24 @@ export interface ISearchSubagentParams {
 	description: string;
 	/** Detailed instructions regarding the search subagent's objective */
 	details: string;
+	/**
+	 * Optional thoroughness level that controls how many tool-call turns the subagent is allowed.
+	 * - 'quick'   → base limit × 0.5  (fast, surface-level scan)
+	 * - 'medium'  → base limit × 1    (default, balanced)
+	 * - 'thorough'→ base limit × 2    (deep, exhaustive search)
+	 * Only active when config.github.copilot.chat.searchSubagent.thoroughnessEnabled is true.
+	 */
+	thoroughness?: 'quick' | 'medium' | 'thorough';
+}
+
+const THOROUGHNESS_MULTIPLIERS: Record<NonNullable<ISearchSubagentParams['thoroughness']>, number> = {
+	quick: 0.5,
+	medium: 1,
+	thorough: 2,
+};
+
+function computeToolCallLimitForThoroughness(baseLimit: number, thoroughness: NonNullable<ISearchSubagentParams['thoroughness']>): number {
+	return Math.max(1, Math.round(baseLimit * THOROUGHNESS_MULTIPLIERS[thoroughness]));
 }
 
 class SearchSubagentTool implements ICopilotTool<ISearchSubagentParams> {
@@ -46,6 +64,30 @@ class SearchSubagentTool implements ICopilotTool<ISearchSubagentParams> {
 		@IConfigurationService private readonly configurationService: IConfigurationService,
 		@IExperimentationService private readonly experimentationService: IExperimentationService
 	) { }
+
+	alternativeDefinition(tool: vscode.LanguageModelToolInformation): vscode.LanguageModelToolInformation {
+		const thoroughnessEnabled = this.configurationService.getExperimentBasedConfig(ConfigKey.Advanced.SearchSubagentThoroughnessEnabled, this.experimentationService);
+		if (!thoroughnessEnabled) {
+			return tool;
+		}
+
+		return {
+			...tool,
+			description: tool.description
+				+ '\n- thoroughness (optional): Search thoroughness — \'quick\' (fewer turns, fast scan), \'medium\' (default), or \'thorough\' (more turns, exhaustive).',
+			inputSchema: {
+				...tool.inputSchema as Record<string, unknown>,
+				properties: {
+					...(tool.inputSchema as { properties: Record<string, unknown> }).properties,
+					thoroughness: {
+						type: 'string',
+						enum: ['quick', 'medium', 'thorough'],
+						description: 'Controls the search thoroughness and turn limit. \'quick\' uses fewer turns (fast scan), \'medium\' is the default, \'thorough\' uses more turns for an exhaustive search.',
+					},
+				},
+			},
+		};
+	}
 	async invoke(options: vscode.LanguageModelToolInvocationOptions<ISearchSubagentParams>, token: vscode.CancellationToken) {
 		// Get the current working directory from workspace folders
 		const workspaceFolders = this.workspaceService.getWorkspaceFolders();
@@ -69,15 +111,21 @@ class SearchSubagentTool implements ICopilotTool<ISearchSubagentParams> {
 		const subAgentInvocationId = generateUuid();
 
 		const toolCallLimit = this.configurationService.getExperimentBasedConfig(ConfigKey.Advanced.SearchSubagentToolCallLimit, this.experimentationService);
+		const thoroughnessEnabled = this.configurationService.getExperimentBasedConfig(ConfigKey.Advanced.SearchSubagentThoroughnessEnabled, this.experimentationService);
+
+		const effectiveToolCallLimit = thoroughnessEnabled && options.input.thoroughness
+			? computeToolCallLimitForThoroughness(toolCallLimit, options.input.thoroughness)
+			: toolCallLimit;
 
 		const loop = this.instantiationService.createInstance(SearchSubagentToolCallingLoop, {
-			toolCallLimit,
+			toolCallLimit: effectiveToolCallLimit,
 			conversation: new Conversation(parentSessionId, [new Turn(generateUuid(), { type: 'user', message: searchInstruction })]),
 			request: request,
 			location: request.location,
 			promptText: options.input.query,
 			subAgentInvocationId: subAgentInvocationId,
 			parentToolCallId: options.chatStreamToolCallId,
+			thoroughness: thoroughnessEnabled ? options.input.thoroughness : undefined,
 		});
 
 		const stream = this._inputContext?.stream && ChatResponseStreamImpl.filter(

extensions/copilot/src/platform/configuration/common/configurationService.ts

@@ -652,6 +652,8 @@ export namespace ConfigKey {
 		export const SearchSubagentModel = defineSetting<string>('chat.searchSubagent.model', ConfigType.ExperimentBased, '');
 		/** Maximum number of tool calls the search subagent can make */
 		export const SearchSubagentToolCallLimit = defineSetting<number>('chat.searchSubagent.toolCallLimit', ConfigType.ExperimentBased, 4);
+		/** Enable the thoroughness parameter on the search subagent tool, which adjusts turn limits based on requested thoroughness */
+		export const SearchSubagentThoroughnessEnabled = defineSetting<boolean>('chat.searchSubagent.thoroughnessEnabled', ConfigType.ExperimentBased, false);
 
 		export const ExecutionSubagentToolEnabled = defineSetting<boolean>('chat.executionSubagent.enabled', ConfigType.ExperimentBased, false);
 		/** Model to use for the execution subagent */