@theia/ai-chat 1.72.0-next.2 → 1.72.0-next.21

package/src/browser/chat-tool-preference-bindings.ts

@@ -18,7 +18,11 @@ import { injectable, inject } from '@theia/core/shared/inversify';
 import {
     PreferenceService,
 } from '@theia/core/lib/common/preferences';
-import { ToolConfirmationMode, TOOL_CONFIRMATION_PREFERENCE } from '../common/chat-tool-preferences';
+import {
+    ToolConfirmationMode,
+    TOOL_CONFIRMATION_PREFERENCE,
+    DEFAULT_TOOL_CONFIRMATION_PREFERENCE
+} from '../common/chat-tool-preferences';
 import { ToolRequest } from '@theia/ai-core';
 import { TrustAwarePreferenceReader } from '@theia/ai-core/lib/browser/trust-aware-preference-reader';
 
@@ -36,12 +40,33 @@ export class ToolConfirmationManager {
     // In-memory session overrides (not persisted), per chat
     protected sessionOverrides: Map<string, Map<string, ToolConfirmationMode>> = new Map();
 
+    /**
+     * Get the global default confirmation mode (used when no tool-specific entry exists).
+     *
+     * Read through the trust-aware reader so that an untrusted workspace cannot override
+     * the default to a more permissive value.
+     */
+    getDefaultConfirmationMode(): ToolConfirmationMode {
+        const value = this.trustAwareReader.get<ToolConfirmationMode>(DEFAULT_TOOL_CONFIRMATION_PREFERENCE);
+        return value ?? this.getDefaultPreferenceSchemaDefault();
+    }
+
+    /**
+     * Set the global default confirmation mode.
+     *
+     * Returns the promise produced by the underlying preference update so callers can
+     * `await` completion and react to errors (e.g. show a notification on failure).
+     */
+    setDefaultConfirmationMode(mode: ToolConfirmationMode): Promise<void> {
+        return this.preferenceService.updateValue(DEFAULT_TOOL_CONFIRMATION_PREFERENCE, mode);
+    }
+
     /**
      * Get the confirmation mode for a specific tool, considering session overrides first (per chat).
      *
      * For tools with `confirmAlwaysAllow` flag:
-     * - They default to CONFIRM mode instead of ALWAYS_ALLOW
-     * - They don't inherit global ALWAYS_ALLOW from the '*' preference
+     * - They default to CONFIRM mode instead of inheriting ALWAYS_ALLOW from the global default.
+     * - Tool-specific preference entries are still respected (informed user consent).
      *
      * @param toolId - The tool identifier
      * @param chatId - The chat session identifier
@@ -55,21 +80,15 @@ export class ToolConfirmationManager {
         const toolConfirmation = this.trustAwareReader.get<Record<string, ToolConfirmationMode>>(
             TOOL_CONFIRMATION_PREFERENCE, {}
         ) ?? {};
-        if (toolConfirmation[toolId]) {
+        if (toolId in toolConfirmation) {
             return toolConfirmation[toolId];
         }
-        if (toolConfirmation['*']) {
-            // For confirmAlwaysAllow tools, don't inherit global ALWAYS_ALLOW
-            if (toolRequest?.confirmAlwaysAllow && toolConfirmation['*'] === ToolConfirmationMode.ALWAYS_ALLOW) {
-                return ToolConfirmationMode.CONFIRM;
-            }
-            return toolConfirmation['*'];
+        const defaultMode = this.getDefaultConfirmationMode();
+        // For confirmAlwaysAllow tools, don't inherit a global ALWAYS_ALLOW default
+        if (toolRequest?.confirmAlwaysAllow && defaultMode === ToolConfirmationMode.ALWAYS_ALLOW) {
+            return ToolConfirmationMode.CONFIRM;
         }
-
-        // Default: ALWAYS_ALLOW for normal tools, CONFIRM for confirmAlwaysAllow tools
-        return toolRequest?.confirmAlwaysAllow
-            ? ToolConfirmationMode.CONFIRM
-            : ToolConfirmationMode.ALWAYS_ALLOW;
+        return defaultMode;
     }
 
     /**
@@ -79,30 +98,20 @@ export class ToolConfirmationManager {
      * @param mode - The confirmation mode to set
      * @param toolRequest - Optional ToolRequest to check for confirmAlwaysAllow flag
      */
-    setConfirmationMode(toolId: string, mode: ToolConfirmationMode, toolRequest?: ToolRequest): void {
-        const defaultPref = this.preferenceService.inspect(TOOL_CONFIRMATION_PREFERENCE)?.defaultValue as {
-            [toolId: string]: ToolConfirmationMode;
-        } || {};
+    setConfirmationMode(toolId: string, mode: ToolConfirmationMode, toolRequest?: ToolRequest): Promise<void> {
         const current = this.trustAwareReader.get<Record<string, ToolConfirmationMode>>(
             TOOL_CONFIRMATION_PREFERENCE, {}
         ) ?? {};
-        let starMode = current['*'];
-        if (starMode === undefined) {
-            starMode = defaultPref['*'] ?? ToolConfirmationMode.ALWAYS_ALLOW;
-        }
-        // For confirmAlwaysAllow tools, the effective default is CONFIRM, not ALWAYS_ALLOW
-        const effectiveDefault = (toolRequest?.confirmAlwaysAllow && starMode === ToolConfirmationMode.ALWAYS_ALLOW)
-            ? ToolConfirmationMode.CONFIRM
-            : defaultPref[toolId] ?? starMode;
+        const effectiveDefault = this.computeEffectiveDefaultForTool(toolId, toolRequest);
         if (mode === effectiveDefault) {
             if (toolId in current) {
                 const { [toolId]: _, ...rest } = current;
-                this.preferenceService.updateValue(TOOL_CONFIRMATION_PREFERENCE, rest);
+                return this.preferenceService.updateValue(TOOL_CONFIRMATION_PREFERENCE, rest);
             }
-        } else {
-            const updated = { ...current, [toolId]: mode };
-            this.preferenceService.updateValue(TOOL_CONFIRMATION_PREFERENCE, updated);
+            return Promise.resolve();
         }
+        const updated = { ...current, [toolId]: mode };
+        return this.preferenceService.updateValue(TOOL_CONFIRMATION_PREFERENCE, updated);
     }
 
     /**
@@ -137,14 +146,37 @@ export class ToolConfirmationManager {
         ) ?? {};
     }
 
-    resetAllConfirmationModeSettings(): void {
-        const current = this.trustAwareReader.get<Record<string, ToolConfirmationMode>>(
-            TOOL_CONFIRMATION_PREFERENCE, {}
-        ) ?? {};
-        if ('*' in current) {
-            this.preferenceService.updateValue(TOOL_CONFIRMATION_PREFERENCE, { '*': current['*'] });
-        } else {
-            this.preferenceService.updateValue(TOOL_CONFIRMATION_PREFERENCE, {});
+    resetAllConfirmationModeSettings(): Promise<void> {
+        return this.preferenceService.updateValue(TOOL_CONFIRMATION_PREFERENCE, {});
+    }
+
+    /**
+     * Compute the effective default for a given tool, taking the schema-level default,
+     * any product-shipped per-tool default, and the confirmAlwaysAllow flag into account.
+     */
+    protected computeEffectiveDefaultForTool(toolId: string, toolRequest?: ToolRequest): ToolConfirmationMode {
+        const perToolDefaults = this.preferenceService.inspect(TOOL_CONFIRMATION_PREFERENCE)?.defaultValue as
+            | { [toolId: string]: ToolConfirmationMode }
+            | undefined;
+        const perToolDefault = perToolDefaults?.[toolId];
+        if (perToolDefault) {
+            return perToolDefault;
         }
+        const globalDefault = this.getDefaultConfirmationMode();
+        if (toolRequest?.confirmAlwaysAllow && globalDefault === ToolConfirmationMode.ALWAYS_ALLOW) {
+            return ToolConfirmationMode.CONFIRM;
+        }
+        return globalDefault;
+    }
+
+    /**
+     * Read the schema-level default for the default-confirmation preference.
+     * Falls back to CONFIRM if the preference service has not registered the schema yet.
+     */
+    protected getDefaultPreferenceSchemaDefault(): ToolConfirmationMode {
+        const schemaDefault = this.preferenceService.inspect(DEFAULT_TOOL_CONFIRMATION_PREFERENCE)?.defaultValue as
+            | ToolConfirmationMode
+            | undefined;
+        return schemaDefault ?? ToolConfirmationMode.CONFIRM;
     }
 }

package/src/common/chat-tool-preferences.ts

@@ -54,25 +54,45 @@ export enum ToolConfirmationMode {
 }
 
 export const TOOL_CONFIRMATION_PREFERENCE = 'ai-features.chat.toolConfirmation';
+export const DEFAULT_TOOL_CONFIRMATION_PREFERENCE = 'ai-features.chat.defaultToolConfirmation';
 export const TOOL_CONFIRMATION_TIMEOUT_PREFERENCE = 'ai-features.chat.toolConfirmationTimeout';
 
+const TOOL_CONFIRMATION_MODE_VALUES = [
+    ToolConfirmationMode.ALWAYS_ALLOW,
+    ToolConfirmationMode.CONFIRM,
+    ToolConfirmationMode.DISABLED
+];
+
+const TOOL_CONFIRMATION_MODE_DESCRIPTIONS = [
+    nls.localize('theia/ai/chat/toolConfirmation/alwaysAllow/description', 'Execute tools automatically without confirmation'),
+    nls.localize('theia/ai/chat/toolConfirmation/confirm/description', 'Ask for confirmation before executing tools'),
+    nls.localize('theia/ai/chat/toolConfirmation/disabled/description', 'Disable tool execution')
+];
+
 export const chatToolPreferences: PreferenceSchema = {
     properties: {
+        [DEFAULT_TOOL_CONFIRMATION_PREFERENCE]: {
+            type: 'string',
+            enum: TOOL_CONFIRMATION_MODE_VALUES,
+            enumDescriptions: TOOL_CONFIRMATION_MODE_DESCRIPTIONS,
+            default: ToolConfirmationMode.CONFIRM,
+            description: nls.localize('theia/ai/chat/defaultToolConfirmation/description',
+                'Default confirmation behavior used for tools that do not have a tool-specific entry under ' +
+                '"ai-features.chat.toolConfirmation". Tools that explicitly require confirmation before being auto-approved ' +
+                'always default to "confirm" regardless of this setting.'),
+            title: AI_CORE_PREFERENCES_TITLE,
+        },
         [TOOL_CONFIRMATION_PREFERENCE]: {
             type: 'object',
             additionalProperties: {
                 type: 'string',
-                enum: [ToolConfirmationMode.ALWAYS_ALLOW, ToolConfirmationMode.CONFIRM, ToolConfirmationMode.DISABLED],
-                enumDescriptions: [
-                    nls.localize('theia/ai/chat/toolConfirmation/yolo/description', 'Execute tools automatically without confirmation'),
-                    nls.localize('theia/ai/chat/toolConfirmation/confirm/description', 'Ask for confirmation before executing tools'),
-                    nls.localize('theia/ai/chat/toolConfirmation/disabled/description', 'Disable tool execution')
-                ]
+                enum: TOOL_CONFIRMATION_MODE_VALUES,
+                enumDescriptions: TOOL_CONFIRMATION_MODE_DESCRIPTIONS
             },
             default: {},
             description: nls.localize('theia/ai/chat/toolConfirmation/description',
-                'Configure confirmation behavior for different tools. Key is the tool ID, value is the confirmation mode. ' +
-                'Use "*" as the key to set a global default for all tools.'),
+                'Configure confirmation behavior for individual tools. Key is the tool ID, value is the confirmation mode. ' +
+                'To change the default for all tools, use "ai-features.chat.defaultToolConfirmation".'),
             title: AI_CORE_PREFERENCES_TITLE,
         },
         [TOOL_CONFIRMATION_TIMEOUT_PREFERENCE]: {
@@ -89,5 +109,6 @@ export const chatToolPreferences: PreferenceSchema = {
 
 export interface ChatToolConfiguration {
     [TOOL_CONFIRMATION_PREFERENCE]: { [toolId: string]: ToolConfirmationMode };
+    [DEFAULT_TOOL_CONFIRMATION_PREFERENCE]: ToolConfirmationMode;
     [TOOL_CONFIRMATION_TIMEOUT_PREFERENCE]: number;
 }