Filter copilot tools (#10742)

Addresses #9770 #10719

Fix copilot tools being included after 1.106 merge Filter copilot tools
from Configure Tools quick pick using the include copilot tools setting

<!-- Thank you for submitting a pull request.
If this is your first pull request you can find information about
contributing here:
  * https://github.com/posit-dev/positron/blob/main/CONTRIBUTING.md

We recommend synchronizing your branch with the latest changes in the
main branch by either pulling or rebasing.
-->

<!--
  Describe briefly what problem this pull request resolves, or what
  new feature it introduces. Include screenshots of any new or altered
  UI. Link to any GitHub issues but avoid "magic" keywords that will
  automatically close the issue. If there are any details about your
  approach that are unintuitive or you want to draw attention to, please
  describe them here.
-->


### Release Notes

Fixes the 1.106 merge that changed how the Copilot tools are included.
They are now built-in tools so we no longer can filter by using the
Copilot extension. All the tools are filtered by the `copilot_` prefix
on the tool name.

Added the same logic to the quick pick UI. If the selected model is not
a Copilot model, the setting is used to determine if the Copilot tools
are shown in the list.

Selected chat model is not Copilot and setting does not include Copilot
tools
<img width="624" height="464" alt="image"
src="https://github.com/user-attachments/assets/f1c42152-cc72-4e2e-9f7b-1a85e3fde879"
/>


Selected chat model is not Copilot and setting does include Copilot
tools
<img width="619" height="601" alt="image"
src="https://github.com/user-attachments/assets/420844de-adbd-4741-8ec6-2e72155c57c4"
/>


<!--
Optionally, replace `N/A` with text to be included in the next release
notes.
The `N/A` bullets are ignored. If you refer to one or more Positron
issues,
these issues are used to collect information about the feature or
bugfix, such
as the relevant language pack as determined by Github labels of type
`lang: `.
  The note will automatically be tagged with the language.

These notes are typically filled by the Positron team. If you are an
external
  contributor, you may ignore this section.
-->

#### New Features

- N/A

#### Bug Fixes

- Fix Copilot tools included in chat requests not using a Copilot model
and filtering the tools from the Configure Tools quick pick


### QA Notes

The Configure Tools action in the chat input shows the quick pick.
Copilot tools are no longer in their own category. They're included in
the Built-In category after the 1.106 upstream merge.

<!--
Positron team members: please add relevant e2e test tags, so the tests
can be
  run when you open this pull request.

- Instructions:
https://github.com/posit-dev/positron/blob/main/test/e2e/README.md#pull-requests-and-test-tags
- Available tags:
https://github.com/posit-dev/positron/blob/main/test/e2e/infra/test-runner/test-tags.ts
-->


<!--
  Add additional information for QA on how to validate the change,
  paying special attention to the level of risk, adjacent areas that
  could be affected by the change, and any important contextual
  information not present in the linked issues.
-->

Author: timtmok

extensions/positron-assistant/src/api.ts

@@ -341,7 +341,7 @@ export function getEnabledTools(
 		// Check if the user has opted-in to always include Copilot tools.
 		const alwaysIncludeCopilotTools = vscode.workspace.getConfiguration('positron.assistant').get('alwaysIncludeCopilotTools', false);
 		// Check if the tool is provided by Copilot.
-		const copilotTool = tool.source instanceof vscode.LanguageModelToolExtensionSource && tool.source.id === 'GitHub.copilot-chat';
+		const copilotTool = tool.name.startsWith('copilot_');
 
 		// Disable Copilot notebook tools when Positron notebook mode is active
 		// to avoid conflicts with Positron's specialized notebook tools.

src/vs/workbench/contrib/chat/browser/actions/chatContext.ts

@@ -33,6 +33,9 @@ import { ITerminalService } from '../../../terminal/browser/terminal.js';
 import { URI } from '../../../../../base/common/uri.js';
 import { ITerminalCommand, TerminalCapability } from '../../../../../platform/terminal/common/capabilities/capabilities.js';
 
+// --- Start Positron ---
+import { ILanguageModelToolsService } from '../../common/languageModelToolsService.js';
+// --- End Positron ---
 
 export class ChatContextContributions extends Disposable implements IWorkbenchContribution {
 
@@ -68,6 +71,12 @@ class ToolsContextPickerPick implements IChatContextPickerItem {
 	readonly icon: ThemeIcon = Codicon.tools;
 	readonly ordinal = -500;
 
+	// --- Start Positron ---
+	constructor(
+		@ILanguageModelToolsService private readonly _languageModelToolsService: ILanguageModelToolsService,
+	) { }
+	// --- End Positron ---
+
 	isEnabled(widget: IChatWidget): boolean {
 		return !!widget.attachmentCapabilities.supportsToolAttachments;
 	}
@@ -77,16 +86,40 @@ class ToolsContextPickerPick implements IChatContextPickerItem {
 		type Pick = IChatContextPickerPickItem & { toolInfo: { ordinal: number; label: string } };
 		const items: Pick[] = [];
 
+		// --- Start Positron ---
+		const selectedLanguageModel = widget.input.selectedLanguageModel;
+		// --- End Positron ---
+
 		for (const [entry, enabled] of widget.input.selectedToolsModel.entriesMap.get()) {
 			if (enabled) {
 				if (entry instanceof ToolSet) {
+					// --- Start Positron ---
+					// If no tools in the set are enabled for the selected model, skip the set
+					const tools = entry.getTools();
+					let hasEnabledTools = false;
+					for (const tool of tools) {
+						if (this._languageModelToolsService.isToolEnabledForModel(tool.id, selectedLanguageModel)) {
+							hasEnabledTools = true;
+							break;
+						}
+					}
+					if (!hasEnabledTools) {
+						continue;
+					}
+					// --- End Positron ---
 					items.push({
 						toolInfo: ToolDataSource.classify(entry.source),
 						label: entry.referenceName,
 						description: entry.description,
 						asAttachment: (): IChatRequestToolSetEntry => toToolSetVariableEntry(entry)
 					});
 				} else {
+					// --- Start Positron ---
+					// Filter out tools not enabled for the selected model
+					if (!this._languageModelToolsService.isToolEnabledForModel(entry.id, selectedLanguageModel)) {
+						continue;
+					}
+					// --- End Positron ---
 					items.push({
 						toolInfo: ToolDataSource.classify(entry.source),
 						label: entry.toolReferenceName ?? entry.displayName,

src/vs/workbench/contrib/chat/browser/actions/chatToolActions.ts

@@ -176,7 +176,10 @@ class ConfigureToolsAction extends Action2 {
 
 		}
 
-		const result = await instaService.invokeFunction(showToolsPicker, placeholder, description, () => entriesMap.get());
+		// --- Start Positron ---
+		// Add selected language model so we can filter tools based on provider compatibility
+		const result = await instaService.invokeFunction(showToolsPicker, placeholder, description, () => entriesMap.get(), widget.input.selectedLanguageModel);
+		// --- End Positron ---
 		if (result) {
 			widget.input.selectedToolsModel.set(result, false);
 		}

src/vs/workbench/contrib/chat/browser/actions/chatToolPicker.ts

@@ -26,6 +26,10 @@ import { ChatContextKeys } from '../../common/chatContextKeys.js';
 import { ILanguageModelToolsService, IToolData, ToolDataSource, ToolSet } from '../../common/languageModelToolsService.js';
 import { ConfigureToolSets } from '../tools/toolSetsContribution.js';
 
+// --- Start Positron ---
+import { ILanguageModelChatMetadataAndIdentifier } from '../../common/languageModels.js';
+// --- End Positron ---
+
 const enum BucketOrdinal { User, BuiltIn, Mcp, Extension }
 
 // Legacy QuickPick types (existing implementation)
@@ -183,14 +187,18 @@ function createToolSetTreeItem(toolset: ToolSet, checked: boolean, editorService
  * @param placeHolder - Placeholder text shown in the picker
  * @param description - Optional description text shown in the picker
  * @param toolsEntries - Optional initial selection state for tools and toolsets
+ * @param selectedLanguageModel - Optional selected language model to filter tools for
  * @param onUpdate - Optional callback fired when the selection changes
  * @returns Promise resolving to the final selection map, or undefined if cancelled
  */
 export async function showToolsPicker(
 	accessor: ServicesAccessor,
 	placeHolder: string,
 	description?: string,
-	getToolsEntries?: () => ReadonlyMap<ToolSet | IToolData, boolean>
+	// --- Start Positron ---
+	getToolsEntries?: () => ReadonlyMap<ToolSet | IToolData, boolean>,
+	selectedLanguageModel?: ILanguageModelChatMetadataAndIdentifier
+	// --- End Positron ---
 ): Promise<ReadonlyMap<ToolSet | IToolData, boolean> | undefined> {
 
 	const quickPickService = accessor.get(IQuickInputService);
@@ -378,6 +386,10 @@ export async function showToolsPicker(
 			return bucket;
 		};
 
+		// --- Start Positron ---
+		const languageModelToolsService = accessor.get(ILanguageModelToolsService);
+		// --- End Positron ---
+
 		for (const toolSet of toolsService.toolSets.get()) {
 			if (!toolsEntries.has(toolSet)) {
 				continue;
@@ -388,13 +400,32 @@ export async function showToolsPicker(
 			}
 			const toolSetChecked = toolsEntries.get(toolSet) === true;
 			if (toolSet.source.type === 'mcp') {
+				// --- Start Positron ---
+				// Check if any tools in this MCP toolset are enabled for the selected model
+				const hasEnabledTools = [...toolSet.getTools()].some(tool =>
+					languageModelToolsService.isToolEnabledForModel(tool.id, selectedLanguageModel)
+				);
+				if (!hasEnabledTools) {
+					continue;
+				}
+				// --- End Positron ---
 				// bucket represents the toolset
 				bucket.toolset = toolSet;
 				if (toolSetChecked) {
 					bucket.checked = toolSetChecked;
 				}
 				// all mcp tools are part of toolsService.getTools()
 			} else {
+				// --- Start Positron ---
+				// Filter tools first to check if any are enabled for the selected model
+				const enabledTools = [...toolSet.getTools()].filter(tool =>
+					languageModelToolsService.isToolEnabledForModel(tool.id, selectedLanguageModel)
+				);
+				// Skip toolset entirely if no tools are enabled for the selected model
+				if (enabledTools.length === 0) {
+					continue;
+				}
+				// --- End Positron ---
 				const treeItem = createToolSetTreeItem(toolSet, toolSetChecked, editorService);
 				bucket.children.push(treeItem);
 				const children = [];
@@ -412,6 +443,12 @@ export async function showToolsPicker(
 			if (!tool.canBeReferencedInPrompt || !toolsEntries.has(tool)) {
 				continue;
 			}
+			// --- Start Positron ---
+			// Filter out tools not enabled for the selected model
+			if (!languageModelToolsService.isToolEnabledForModel(tool.id, selectedLanguageModel)) {
+				continue;
+			}
+			// --- End Positron ---
 			const bucket = getBucket(tool.source);
 			if (!bucket) {
 				continue;

src/vs/workbench/contrib/chat/browser/languageModelToolsService.ts

@@ -44,6 +44,10 @@ import { CountTokensCallback, createToolSchemaUri, GithubCopilotToolReference, I
 import { Target } from '../common/promptSyntax/promptFileParser.js';
 import { getToolConfirmationAlert } from './chatAccessibilityProvider.js';
 
+// --- Start Positron ---
+import { ILanguageModelChatMetadataAndIdentifier } from '../common/languageModels.js';
+// --- End Positron ---
+
 const jsonSchemaRegistry = Registry.as<JSONContributionRegistry.IJSONContributionRegistry>(JSONContributionRegistry.Extensions.JSONContribution);
 
 interface IToolEntry {
@@ -672,6 +676,33 @@ export class LanguageModelToolsService extends Disposable implements ILanguageMo
 		return result;
 	}
 
+	// --- Start Positron ---
+	// Determines if a tool should be enabled for the currently selected language model.
+	// Based on the logic from chatToolPicker.ts
+	isToolEnabledForModel(toolId: string, selectedLanguageModel: ILanguageModelChatMetadataAndIdentifier | undefined): boolean {
+		// If no model is selected, enable all tools
+		if (!selectedLanguageModel) {
+			return true;
+		}
+
+		// Check if the user is using a Copilot model
+		const usingCopilotModel = selectedLanguageModel.metadata.vendor === 'copilot';
+		// Check if the user has opted-in to always include Copilot tools.
+		const alwaysIncludeCopilotTools = this._configurationService.getValue('positron.assistant.alwaysIncludeCopilotTools') as boolean;
+		// Check if the tool is provided by Copilot
+		const copilotTool = toolId.startsWith('copilot_');
+
+		// Enable Copilot tools only if using a Copilot model;
+		// otherwise, enable all non-Copilot tools
+		if (copilotTool) {
+			return usingCopilotModel || alwaysIncludeCopilotTools;
+		}
+
+		// All non-Copilot tools are enabled for all models
+		return true;
+	};
+	// --- End Positron ---
+
 	toQualifiedToolNames(map: IToolAndToolSetEnablementMap): string[] {
 		const result: string[] = [];
 		const toolsCoveredByEnabledToolSet = new Set<IToolData>();

src/vs/workbench/contrib/chat/common/languageModelToolsService.ts

@@ -29,6 +29,10 @@ import { ChatRequestToolReferenceEntry } from './chatVariableEntries.js';
 import { LanguageModelPartAudience } from './languageModels.js';
 import { PromptElementJSON, stringifyPromptElementJSON } from './tools/promptTsxTypes.js';
 
+// --- Start Positron ---
+import { ILanguageModelChatMetadataAndIdentifier } from '../common/languageModels.js';
+// --- End Positron ---
+
 export interface IToolData {
 	id: string;
 	source: ToolDataSource;
@@ -371,6 +375,10 @@ export interface ILanguageModelToolsService {
 	toToolAndToolSetEnablementMap(qualifiedToolOrToolSetNames: readonly string[], target: string | undefined): IToolAndToolSetEnablementMap;
 	toQualifiedToolNames(map: IToolAndToolSetEnablementMap): string[];
 	toToolReferences(variableReferences: readonly IVariableReference[]): ChatRequestToolReferenceEntry[];
+
+	// --- Start Positron ---
+	isToolEnabledForModel(toolId: string, selectedLanguageModel: ILanguageModelChatMetadataAndIdentifier | undefined): boolean;
+	// --- End Positron ---
 }
 
 export function createToolInputUri(toolCallId: string): URI {

src/vs/workbench/contrib/chat/test/common/mockLanguageModelToolsService.ts

@@ -12,6 +12,10 @@ import { IVariableReference } from '../../common/chatModes.js';
 import { ChatRequestToolReferenceEntry } from '../../common/chatVariableEntries.js';
 import { CountTokensCallback, ILanguageModelToolsService, IToolAndToolSetEnablementMap, IToolData, IToolImpl, IToolInvocation, IToolResult, ToolSet } from '../../common/languageModelToolsService.js';
 
+// --- Start Positron ---
+import { ILanguageModelChatMetadataAndIdentifier } from '../../common/languageModels.js';
+// --- End Positron ---
+
 export class MockLanguageModelToolsService implements ILanguageModelToolsService {
 	_serviceBrand: undefined;
 
@@ -100,6 +104,12 @@ export class MockLanguageModelToolsService implements ILanguageModelToolsService
 		throw new Error('Method not implemented.');
 	}
 
+	// --- Start Positron ---
+	isToolEnabledForModel(toolId: string, languageModel: ILanguageModelChatMetadataAndIdentifier | undefined): boolean {
+		throw new Error('Method not implemented.');
+	}
+	// --- End Positron ---
+
 	toToolReferences(variableReferences: readonly IVariableReference[]): ChatRequestToolReferenceEntry[] {
 		throw new Error('Method not implemented.');
 	}