Introduce a ICopilotToolExtension to support override existing built-in tools and provide alternative definition.

Author: bryanchen-d

src/extension/tools/common/toolsRegistry.ts

@@ -26,7 +26,7 @@ export enum CopilotToolMode {
 	FullContext,
 }
 
-export interface ICopilotTool<T> extends vscode.LanguageModelTool<T> {
+export interface ICopilotToolExtension<T> {
 	/**
 	 * Called when edits are made in a tool call response. The tool can return
 	 * a confirmation that will be shown to the user before edits are applied.
@@ -55,10 +55,16 @@ export interface ICopilotTool<T> extends vscode.LanguageModelTool<T> {
 	 * parameters because the alternative definition will only be applied within
 	 * the Copilot extension, not other extensions' usages via `vscode.lm.tools`.
 	 *
+	 * @param tool The original tool definition.
 	 * @param endpoint Optional information about the currently selected language model endpoint.
 	 *                 If provided, allows customizing the tool definition per endpoint.
+	 *
+	 * @return An overridden tool definition.
 	 */
-	alternativeDefinition?(endpoint?: IChatEndpoint): vscode.LanguageModelToolInformation | undefined;
+	alternativeDefinition?(tool: vscode.LanguageModelToolInformation, endpoint?: IChatEndpoint): vscode.LanguageModelToolInformation;
+}
+
+export interface ICopilotTool<T> extends vscode.LanguageModelTool<T>, ICopilotToolExtension<T> {
 }
 
 
@@ -67,8 +73,14 @@ export interface ICopilotToolCtor {
 	new(...args: any[]): ICopilotTool<any>;
 }
 
+export interface ICopilotToolExtensionCtor {
+	readonly toolName: ToolName;
+	new(...args: any[]): ICopilotToolExtension<any>;
+}
+
 export const ToolRegistry = new class {
 	private _tools: ICopilotToolCtor[] = [];
+	private _toolExtensions: ICopilotToolExtensionCtor[] = [];
 
 	public registerTool(tool: ICopilotToolCtor) {
 		this._tools.push(tool);
@@ -77,4 +89,12 @@ export const ToolRegistry = new class {
 	public getTools(): readonly ICopilotToolCtor[] {
 		return this._tools;
 	}
+
+	public registerToolExtension(tool: ICopilotToolExtensionCtor) {
+		this._toolExtensions.push(tool);
+	}
+
+	public getToolExtensions(): readonly ICopilotToolExtensionCtor[] {
+		return this._toolExtensions;
+	}
 }();

src/extension/tools/node/manageTodoListToolEx.tsx

@@ -0,0 +1,45 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import type * as vscode from 'vscode';
+import { ILogService } from '../../../platform/log/common/logService';
+import { IChatEndpoint } from '../../../platform/networking/common/networking';
+import { ToolName } from '../common/toolNames';
+import { ICopilotToolExtension, ToolRegistry } from '../common/toolsRegistry';
+
+interface IManageTodoListParams {
+	operation: 'write' | 'read';
+	todoList?: readonly {
+		readonly id: number;
+		readonly title: string;
+		readonly description: string;
+		readonly status: 'not-started' | 'in-progress' | 'completed';
+	}[];
+}
+
+
+/**
+ * A thin wrapper tool to provide custom behavior on top of the internal manage_todo_list tool.
+ * This allows the extension to override the tool definition based on the model or other factors.
+ */
+class ManageTodoListToolExtension implements ICopilotToolExtension<IManageTodoListParams> {
+	static readonly toolName = ToolName.CoreManageTodoList;
+	constructor(
+		@ILogService readonly _logService: ILogService
+	) { }
+
+	alternativeDefinition(originTool: vscode.LanguageModelToolInformation, chatEndpoint: IChatEndpoint | undefined): vscode.LanguageModelToolInformation {
+		// specialize the tool definition for gpt-5 to reduce the frequency
+		if (chatEndpoint?.model === 'gpt-5') {
+			return {
+				...originTool,
+				description: originTool.description?.replace('VERY frequently ', ''),
+			};
+		}
+
+		return originTool;
+	}
+}
+
+ToolRegistry.registerToolExtension(ManageTodoListToolExtension);

src/extension/tools/node/readFileTool.tsx

@@ -178,10 +178,12 @@ export class ReadFileTool implements ICopilotTool<ReadFileParams> {
 		};
 	}
 
-	public alternativeDefinition(): vscode.LanguageModelToolInformation | undefined {
+	public alternativeDefinition(originTool: vscode.LanguageModelToolInformation): vscode.LanguageModelToolInformation {
 		if (this.configurationService.getExperimentBasedConfig<boolean>(ConfigKey.Internal.EnableReadFileV2, this.experimentationService)) {
 			return readFileV2Description;
 		}
+
+		return originTool;
 	}
 
 	private async getSnapshot(uri: URI) {

src/extension/tools/node/test/testToolsService.ts

@@ -36,7 +36,7 @@ export class TestToolsService extends BaseToolsService implements IToolsService
 	get tools(): LanguageModelToolInformation[] {
 		return Array.from(this._tools.values()).map(tool => {
 			const owned = this._copilotTools.get(getToolName(tool.name) as ToolName);
-			return owned?.value.alternativeDefinition?.() ?? tool;
+			return owned?.value.alternativeDefinition?.(tool) ?? tool;
 		});
 	}
 
@@ -149,7 +149,7 @@ export class TestToolsService extends BaseToolsService implements IToolsService
 				// Apply model-specific alternative if available via alternativeDefinition
 				const owned = this._copilotTools.get(getToolName(tool.name) as ToolName);
 				if (owned?.value?.alternativeDefinition) {
-					const alternative = owned.value.alternativeDefinition(endpoint);
+					const alternative = owned.value.alternativeDefinition(tool, endpoint);
 					if (alternative) {
 						return alternative;
 					}

src/extension/tools/vscode-node/toolsService.ts

@@ -10,13 +10,17 @@ import { equals as arraysEqual } from '../../../util/vs/base/common/arrays';
 import { Lazy } from '../../../util/vs/base/common/lazy';
 import { IInstantiationService } from '../../../util/vs/platform/instantiation/common/instantiation';
 import { getContributedToolName, getToolName, mapContributedToolNamesInSchema, mapContributedToolNamesInString, ToolName } from '../common/toolNames';
-import { ICopilotTool, ToolRegistry } from '../common/toolsRegistry';
+import { ICopilotTool, ICopilotToolExtension, ToolRegistry } from '../common/toolsRegistry';
 import { BaseToolsService } from '../common/toolsService';
 
 export class ToolsService extends BaseToolsService {
 	declare _serviceBrand: undefined;
 
 	private readonly _copilotTools: Lazy<Map<ToolName, ICopilotTool<any>>>;
+
+	// Extensions to override definitions for existing tools.
+	private readonly _toolExtensions: Lazy<Map<ToolName, ICopilotToolExtension<any>>>;
+
 	private readonly _contributedToolCache: {
 		input: readonly vscode.LanguageModelToolInformation[];
 		output: readonly vscode.LanguageModelToolInformation[];
@@ -43,7 +47,7 @@ export class ToolsService extends BaseToolsService {
 			})
 			.map(tool => {
 				const owned = this._copilotTools.value.get(getToolName(tool.name) as ToolName);
-				return owned?.alternativeDefinition?.() ?? tool;
+				return owned?.alternativeDefinition?.(tool) ?? tool;
 			});
 
 		const result: vscode.LanguageModelToolInformation[] = contributedTools.map(tool => {
@@ -71,6 +75,7 @@ export class ToolsService extends BaseToolsService {
 	) {
 		super(logService);
 		this._copilotTools = new Lazy(() => new Map(ToolRegistry.getTools().map(t => [t.toolName, instantiationService.createInstance(t)] as const)));
+		this._toolExtensions = new Lazy(() => new Map(ToolRegistry.getToolExtensions().map(t => [t.toolName, instantiationService.createInstance(t)] as const)));
 	}
 
 	invokeTool(name: string | ToolName, options: vscode.LanguageModelToolInvocationOptions<Object>, token: vscode.CancellationToken): Thenable<vscode.LanguageModelToolResult | vscode.LanguageModelToolResult2> {
@@ -99,13 +104,17 @@ export class ToolsService extends BaseToolsService {
 			.map(tool => {
 				// Apply model-specific alternative if available via alternativeDefinition
 				const owned = this._copilotTools.value.get(getToolName(tool.name) as ToolName);
+				let resultTool = tool;
 				if (owned?.alternativeDefinition) {
-					const alternative = owned.alternativeDefinition(endpoint);
-					if (alternative) {
-						return alternative;
-					}
+					resultTool = owned.alternativeDefinition(resultTool, endpoint);
 				}
-				return tool;
+
+				const extension = this._toolExtensions.value.get(getToolName(tool.name) as ToolName);
+				if (extension?.alternativeDefinition) {
+					resultTool = extension.alternativeDefinition(resultTool, endpoint);
+				}
+
+				return resultTool;
 			})
 			.filter(tool => {
 				// 0. Check if the tool was disabled via the tool picker. If so, it must be disabled here

test/base/extHostContext/simulationExtHostToolsService.ts

@@ -128,7 +128,7 @@ export class SimulationExtHostToolsService extends BaseToolsService implements I
 				// Apply model-specific alternative if available via alternativeDefinition
 				const owned = this.copilotTools.get(getToolName(tool.name) as ToolName);
 				if (owned?.alternativeDefinition) {
-					const alternative = owned.alternativeDefinition(endpoint);
+					const alternative = owned.alternativeDefinition(tool, endpoint);
 					if (alternative) {
 						return alternative;
 					}