Move inlined permission handling into a concrete registry and add AskUserQuestion handling (#2901)

This is mostly just fleshing out code so it's easier to extension... but with:
* A quick and dirty AskUserQuestion tool handling
* localized some strings
* Tests

Author: TylerLeonhardt

src/extension/agents/claude/common/claudeToolPermission.ts

@@ -0,0 +1,84 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { ClaudeToolInputMap, ClaudeToolNames } from './claudeTools';
+
+/**
+ * Result type for tool permission checks, matching the Claude SDK canUseTool return type
+ */
+export type ClaudeToolPermissionResult =
+	| { behavior: 'allow'; updatedInput: Record<string, unknown> }
+	| { behavior: 'deny'; message: string };
+
+/**
+ * Context passed to tool permission handlers
+ */
+export interface ClaudeToolPermissionContext {
+	readonly toolInvocationToken: vscode.ChatParticipantToolToken;
+}
+
+/**
+ * Parameters for showing a confirmation dialog to the user
+ */
+export interface IClaudeToolConfirmationParams {
+	readonly title: string;
+	readonly message: string;
+	readonly confirmationType?: 'basic' | 'terminal';
+	readonly terminalCommand?: string;
+}
+
+/**
+ * Handler interface for tool permission checks.
+ * Implement any combination of these methods to customize behavior:
+ * - canAutoApprove: Return true to skip confirmation dialog
+ * - getConfirmationParams: Customize the confirmation dialog
+ * - handle: Full implementation that bypasses default confirmation flow
+ *
+ * @template TToolName The tool name(s) this handler supports
+ */
+export interface IClaudeToolPermissionHandler<TToolName extends ClaudeToolNames = ClaudeToolNames> {
+	/**
+	 * The tool name(s) this handler is registered for
+	 */
+	readonly toolNames: readonly TToolName[];
+
+	/**
+	 * Check if the tool can be auto-approved without user confirmation.
+	 * If not implemented or returns false, continues to confirmation dialog.
+	 */
+	canAutoApprove?(
+		toolName: TToolName,
+		input: ClaudeToolInputMap[TToolName],
+		context: ClaudeToolPermissionContext
+	): Promise<boolean>;
+
+	/**
+	 * Get custom confirmation dialog parameters.
+	 * If not implemented, uses default confirmation params.
+	 */
+	getConfirmationParams?(
+		toolName: TToolName,
+		input: ClaudeToolInputMap[TToolName]
+	): IClaudeToolConfirmationParams;
+
+	/**
+	 * Full custom handler implementation.
+	 * If implemented, bypasses canAutoApprove and getConfirmationParams entirely.
+	 * Use this for tools like AskUserQuestion that need complete custom behavior.
+	 */
+	handle?(
+		toolName: TToolName,
+		input: ClaudeToolInputMap[TToolName],
+		context: ClaudeToolPermissionContext
+	): Promise<ClaudeToolPermissionResult>;
+}
+
+/**
+ * Constructor type for tool permission handlers
+ */
+export type IClaudeToolPermissionHandlerCtor<TToolName extends ClaudeToolNames = ClaudeToolNames> =
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Constructor types for DI require 'any' for parameter compatibility
+	new (...args: any[]) => IClaudeToolPermissionHandler<TToolName>;

src/extension/agents/claude/common/claudeToolPermissionRegistry.ts

@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IClaudeToolPermissionHandlerCtor } from './claudeToolPermission';
+import { ClaudeToolNames } from './claudeTools';
+
+/**
+ * Registry entry for tool permission handlers
+ */
+export interface IToolPermissionHandlerRegistration {
+	readonly toolNames: readonly ClaudeToolNames[];
+	readonly ctor: IClaudeToolPermissionHandlerCtor;
+}
+
+/**
+ * Registry of tool permission handlers.
+ * Handlers can register from common/, node/, or vscode-node/ folders.
+ */
+const handlerRegistry: IToolPermissionHandlerRegistration[] = [];
+
+/**
+ * Register a tool permission handler for one or more tools.
+ * Handlers are instantiated lazily via the instantiation service.
+ *
+ * @param toolNames The tool name(s) to register the handler for
+ * @param ctor The handler constructor
+ */
+export function registerToolPermissionHandler<T extends ClaudeToolNames>(
+	toolNames: readonly T[],
+	ctor: IClaudeToolPermissionHandlerCtor<T>
+): void {
+	handlerRegistry.push({ toolNames, ctor });
+}
+
+/**
+ * Get all registered tool permission handlers.
+ * Used by ClaudeToolPermissionService to look up handlers.
+ */
+export function getToolPermissionHandlerRegistry(): readonly IToolPermissionHandlerRegistration[] {
+	return handlerRegistry;
+}

src/extension/agents/claude/common/claudeToolPermissionService.ts

@@ -0,0 +1,139 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as l10n from '@vscode/l10n';
+import { CancellationToken } from '../../../../util/vs/base/common/cancellation';
+import { IInstantiationService, createDecorator } from '../../../../util/vs/platform/instantiation/common/instantiation';
+import { LanguageModelTextPart } from '../../../../vscodeTypes';
+import { ToolName } from '../../../tools/common/toolNames';
+import { IToolsService } from '../../../tools/common/toolsService';
+import {
+	ClaudeToolPermissionContext,
+	ClaudeToolPermissionResult,
+	IClaudeToolConfirmationParams,
+	IClaudeToolPermissionHandler
+} from './claudeToolPermission';
+import { getToolPermissionHandlerRegistry } from './claudeToolPermissionRegistry';
+import { ClaudeToolInputMap, ClaudeToolNames } from './claudeTools';
+
+export const IClaudeToolPermissionService = createDecorator<IClaudeToolPermissionService>('claudeToolPermissionService');
+
+export interface IClaudeToolPermissionService {
+	readonly _serviceBrand: undefined;
+
+	/**
+	 * Check if a tool can be used, showing confirmation if needed.
+	 * @param toolName The name of the Claude tool
+	 * @param input The tool input parameters
+	 * @param context Context including the tool invocation token
+	 * @returns Permission result (allow with updated input, or deny with message)
+	 */
+	canUseTool(
+		toolName: string,
+		input: Record<string, unknown>,
+		context: ClaudeToolPermissionContext
+	): Promise<ClaudeToolPermissionResult>;
+}
+
+/**
+ * Default deny message when user declines a tool
+ */
+const DenyToolMessage = 'The user declined to run the tool';
+
+export class ClaudeToolPermissionService implements IClaudeToolPermissionService {
+	declare readonly _serviceBrand: undefined;
+
+	private readonly _handlerCache = new Map<ClaudeToolNames, IClaudeToolPermissionHandler>();
+
+	constructor(
+		@IInstantiationService private readonly instantiationService: IInstantiationService,
+		@IToolsService private readonly toolsService: IToolsService,
+	) { }
+
+	public async canUseTool(
+		toolName: string,
+		input: Record<string, unknown>,
+		context: ClaudeToolPermissionContext
+	): Promise<ClaudeToolPermissionResult> {
+		const handler = this._getHandler(toolName as ClaudeToolNames);
+
+		// If handler has full custom implementation, use it
+		if (handler?.handle) {
+			return handler.handle(toolName as ClaudeToolNames, input as ClaudeToolInputMap[ClaudeToolNames], context);
+		}
+
+		// Check auto-approve
+		if (handler?.canAutoApprove) {
+			const canAutoApprove = await handler.canAutoApprove(toolName as ClaudeToolNames, input as ClaudeToolInputMap[ClaudeToolNames], context);
+			if (canAutoApprove) {
+				return { behavior: 'allow', updatedInput: input };
+			}
+		}
+
+		// Get confirmation params (custom or default)
+		const confirmationParams = handler?.getConfirmationParams
+			? handler.getConfirmationParams(toolName as ClaudeToolNames, input as ClaudeToolInputMap[ClaudeToolNames])
+			: this._getDefaultConfirmationParams(toolName, input);
+
+		// Show confirmation dialog
+		return this._showConfirmation(confirmationParams, input, context);
+	}
+
+	private _getHandler(toolName: ClaudeToolNames): IClaudeToolPermissionHandler | undefined {
+		// Check cache first
+		if (this._handlerCache.has(toolName)) {
+			return this._handlerCache.get(toolName);
+		}
+
+		// Find registration for this tool
+		const registration = getToolPermissionHandlerRegistry().find(r => r.toolNames.includes(toolName));
+		if (!registration) {
+			return undefined;
+		}
+
+		// Create handler instance
+		const handler = this.instantiationService.createInstance(registration.ctor);
+		// Cache for all tool names this handler supports
+		for (const name of registration.toolNames) {
+			this._handlerCache.set(name, handler);
+		}
+
+		return handler;
+	}
+
+	private _getDefaultConfirmationParams(toolName: string, input: Record<string, unknown>): IClaudeToolConfirmationParams {
+		return {
+			title: l10n.t('Use {0}?', toolName),
+			message: `\`\`\`\n${JSON.stringify(input, null, 2)}\n\`\`\``,
+			confirmationType: 'basic'
+		};
+	}
+
+	private async _showConfirmation(
+		params: IClaudeToolConfirmationParams,
+		input: Record<string, unknown>,
+		context: ClaudeToolPermissionContext
+	): Promise<ClaudeToolPermissionResult> {
+		try {
+			const result = await this.toolsService.invokeTool(ToolName.CoreConfirmationTool, {
+				input: params,
+				toolInvocationToken: context.toolInvocationToken,
+			}, CancellationToken.None);
+
+			const firstResultPart = result.content.at(0);
+			if (firstResultPart instanceof LanguageModelTextPart && firstResultPart.value === 'yes') {
+				return {
+					behavior: 'allow',
+					updatedInput: input
+				};
+			}
+		} catch { }
+
+		return {
+			behavior: 'deny',
+			message: DenyToolMessage
+		};
+	}
+}