Pass IChatEndpoint in getEnabledTools for calling tools' alternativeDefinition

Author: bryanchen-d

src/extension/intents/node/agentIntent.ts

@@ -109,7 +109,7 @@ export const getAgentTools = (instaService: IInstantiationService, request: vsco
 			allowTools[ToolName.MultiReplaceString] = false;
 		}
 
-		const tools = toolsService.getEnabledTools(request, tool => {
+		const tools = toolsService.getEnabledTools(request, model, tool => {
 			if (typeof allowTools[tool.name] === 'boolean') {
 				return allowTools[tool.name];
 			}

src/extension/intents/node/askAgentIntent.ts

@@ -36,12 +36,14 @@ const getTools = (instaService: IInstantiationService, request: vscode.ChatReque
 	instaService.invokeFunction(async accessor => {
 		const toolsService = accessor.get<IToolsService>(IToolsService);
 		const lookForTags = new Set<string>(['vscode_codesearch']);
+		const endpointProvider = accessor.get<IEndpointProvider>(IEndpointProvider);
+		const model = await endpointProvider.getChatEndpoint(request);
 
 		// Special case...
 		// Since AskAgent currently has no tool picker, have to duplicate the toolReference logic here.
 		// When it's no longer experimental, it should be a custom mode, have a tool picker, etc.
 		// And must return boolean to avoid falling back on other logic that we don't want, like the `extension_installed_by_tool` check.
-		return toolsService.getEnabledTools(request, tool => tool.tags.some(tag => lookForTags.has(tag)) || request.toolReferences.some(ref => ref.name === tool.name));
+		return toolsService.getEnabledTools(request, model, tool => tool.tags.some(tag => lookForTags.has(tag)) || request.toolReferences.some(ref => ref.name === tool.name));
 	});
 
 export class AskAgentIntent implements IIntent {

src/extension/intents/node/editCodeIntent2.ts

@@ -57,7 +57,7 @@ const getTools = (instaService: IInstantiationService, request: vscode.ChatReque
 			lookForTools.add(ToolName.RunNotebookCell);
 		}
 
-		return toolsService.getEnabledTools(request, tool => lookForTools.has(tool.name));
+		return toolsService.getEnabledTools(request, model, tool => lookForTools.has(tool.name));
 	});
 
 export class EditCode2Intent extends EditCodeIntent {

src/extension/intents/node/notebookEditorIntent.ts

@@ -59,7 +59,7 @@ const getTools = (instaService: IInstantiationService, request: vscode.ChatReque
 		lookForTools.add(ToolName.RunNotebookCell);
 		lookForTools.add(ToolName.ReadCellOutput);
 
-		return toolsService.getEnabledTools(request, tool => lookForTools.has(tool.name) || tool.tags.includes('notebooks'));
+		return toolsService.getEnabledTools(request, model, tool => lookForTools.has(tool.name) || tool.tags.includes('notebooks'));
 	});
 
 export class NotebookEditorIntent extends EditCodeIntent {

src/extension/intents/node/vscodeIntent.ts

@@ -51,7 +51,7 @@ class VSCodeIntentInvocation extends RendererIntentInvocation implements IIntent
 	}
 
 	getAvailableTools(): vscode.LanguageModelToolInformation[] | Promise<vscode.LanguageModelToolInformation[]> | undefined {
-		return this.toolsService.getEnabledTools(this.request, tool =>
+		return this.toolsService.getEnabledTools(this.request, this.endpoint, tool =>
 			tool.name === 'vscode_searchExtensions_internal' ||
 			tool.name === ToolName.VSCodeAPI
 		);

src/extension/prompt/node/codebaseToolCalling.ts

@@ -64,7 +64,8 @@ export class CodebaseToolCallingLoop extends ToolCallingLoop<ICodebaseToolCallin
 	}
 
 	protected async getAvailableTools(): Promise<LanguageModelToolInformation[]> {
-		return this.toolsService.getEnabledTools(this.options.request, tool => tool.tags.includes('vscode_codesearch'));
+		const endpoint = await this.getEndpoint(this.options.request);
+		return this.toolsService.getEnabledTools(this.options.request, endpoint, tool => tool.tags.includes('vscode_codesearch'));
 	}
 
 	protected async fetch({ messages, finishedCb, requestOptions }: ToolCallingLoopFetchOptions, token: CancellationToken): Promise<ChatResponse> {

src/extension/tools/common/toolsRegistry.ts

@@ -4,6 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import type * as vscode from 'vscode';
+import { IChatEndpoint } from '../../../platform/networking/common/networking';
 import { URI } from '../../../util/vs/base/common/uri';
 import { IBuildPromptContext } from '../../prompt/common/intents';
 import { ToolName } from './toolNames';
@@ -54,10 +55,10 @@ 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 modelInfo Optional information about the currently selected language model.
-	 *                  If provided, allows customizing the tool definition per model.
+	 * @param endpoint Optional information about the currently selected language model endpoint.
+	 *                 If provided, allows customizing the tool definition per endpoint.
 	 */
-	alternativeDefinition?(modelInfo?: vscode.LanguageModelChat): vscode.LanguageModelToolInformation | undefined;
+	alternativeDefinition?(endpoint?: IChatEndpoint): vscode.LanguageModelToolInformation | undefined;
 }
 
 

src/extension/tools/common/toolsService.ts

@@ -6,6 +6,7 @@
 import Ajv, { ValidateFunction } from 'ajv';
 import type * as vscode from 'vscode';
 import { ILogService } from '../../../platform/log/common/logService';
+import { IChatEndpoint } from '../../../platform/networking/common/networking';
 import { LRUCache } from '../../../util/common/cache';
 import { createServiceIdentifier } from '../../../util/common/services';
 import { Emitter, Event } from '../../../util/vs/base/common/event';
@@ -67,7 +68,7 @@ export interface IToolsService {
 	 * pass `filter` function that can explicitl enable (true) or disable (false)
 	 * a tool, or use the default logic (undefined).
 	 */
-	getEnabledTools(request: vscode.ChatRequest, filter?: (tool: vscode.LanguageModelToolInformation) => boolean | undefined): vscode.LanguageModelToolInformation[];
+	getEnabledTools(request: vscode.ChatRequest, endpoint: IChatEndpoint, filter?: (tool: vscode.LanguageModelToolInformation) => boolean | undefined): vscode.LanguageModelToolInformation[];
 }
 
 /**
@@ -160,7 +161,7 @@ export abstract class BaseToolsService extends Disposable implements IToolsServi
 	abstract invokeTool(name: string, options: vscode.LanguageModelToolInvocationOptions<Object>, token: vscode.CancellationToken): Thenable<vscode.LanguageModelToolResult2>;
 	abstract getTool(name: string): vscode.LanguageModelToolInformation | undefined;
 	abstract getToolByToolReferenceName(name: string): vscode.LanguageModelToolInformation | undefined;
-	abstract getEnabledTools(request: vscode.ChatRequest, filter?: (tool: vscode.LanguageModelToolInformation) => boolean | undefined): vscode.LanguageModelToolInformation[];
+	abstract getEnabledTools(request: vscode.ChatRequest, endpoint: IChatEndpoint, filter?: (tool: vscode.LanguageModelToolInformation) => boolean | undefined): vscode.LanguageModelToolInformation[];
 
 	constructor(
 		@ILogService private readonly logService: ILogService

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

@@ -7,6 +7,7 @@ import type * as vscode from 'vscode';
 import { packageJson } from '../../../../platform/env/common/packagejson';
 import { ILanguageDiagnosticsService } from '../../../../platform/languages/common/languageDiagnosticsService';
 import { ILogService } from '../../../../platform/log/common/logService';
+import { IChatEndpoint } from '../../../../platform/networking/common/networking';
 import { CancellationToken } from '../../../../util/vs/base/common/cancellation';
 import { CancellationError } from '../../../../util/vs/base/common/errors';
 import { Iterable } from '../../../../util/vs/base/common/iterator';
@@ -139,7 +140,7 @@ export class TestToolsService extends BaseToolsService implements IToolsService
 		return undefined;
 	}
 
-	getEnabledTools(request: vscode.ChatRequest, filter?: (tool: LanguageModelToolInformation) => boolean | undefined): LanguageModelToolInformation[] {
+	getEnabledTools(request: vscode.ChatRequest, endpoint: IChatEndpoint, filter?: (tool: LanguageModelToolInformation) => boolean | undefined): LanguageModelToolInformation[] {
 		const toolMap = new Map(this.tools.map(t => [t.name, t]));
 
 		const packageJsonTools = getPackagejsonToolsForTest();
@@ -148,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(request.model);
+					const alternative = owned.value.alternativeDefinition(endpoint);
 					if (alternative) {
 						return alternative;
 					}

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

@@ -5,6 +5,7 @@
 
 import * as vscode from 'vscode';
 import { ILogService } from '../../../platform/log/common/logService';
+import { IChatEndpoint } from '../../../platform/networking/common/networking';
 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';
@@ -91,15 +92,15 @@ export class ToolsService extends BaseToolsService {
 		throw new Error('This method for tests only');
 	}
 
-	getEnabledTools(request: vscode.ChatRequest, filter?: (tool: vscode.LanguageModelToolInformation) => boolean | undefined): vscode.LanguageModelToolInformation[] {
+	getEnabledTools(request: vscode.ChatRequest, endpoint: IChatEndpoint, filter?: (tool: vscode.LanguageModelToolInformation) => boolean | undefined): vscode.LanguageModelToolInformation[] {
 		const toolMap = new Map(this.tools.map(t => [t.name, t]));
 
 		return this.tools
 			.map(tool => {
 				// Apply model-specific alternative if available via alternativeDefinition
 				const owned = this._copilotTools.value.get(getToolName(tool.name) as ToolName);
 				if (owned?.alternativeDefinition) {
-					const alternative = owned.alternativeDefinition(request.model);
+					const alternative = owned.alternativeDefinition(endpoint);
 					if (alternative) {
 						return alternative;
 					}