@theia/ai-chat 1.62.1 → 1.63.0-next.24

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

@@ -0,0 +1,178 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { AI_CORE_PREFERENCES_TITLE } from '@theia/ai-core/lib/browser/ai-core-preferences';
+import { nls } from '@theia/core';
+import { interfaces, injectable, inject } from '@theia/core/shared/inversify';
+import {
+    createPreferenceProxy,
+    PreferenceProxy,
+    PreferenceService,
+    PreferenceSchema,
+    PreferenceContribution
+} from '@theia/core/lib/browser/preferences';
+
+/**
+ * Enum for tool confirmation modes
+ */
+export enum ToolConfirmationMode {
+    YOLO = 'yolo',
+    CONFIRM = 'confirm',
+    DISABLED = 'disabled'
+}
+
+export const TOOL_CONFIRMATION_PREFERENCE = 'ai-features.chat.toolConfirmation';
+
+export const chatToolPreferences: PreferenceSchema = {
+    type: 'object',
+    properties: {
+        [TOOL_CONFIRMATION_PREFERENCE]: {
+            type: 'object',
+            additionalProperties: {
+                type: 'string',
+                enum: [ToolConfirmationMode.YOLO, 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')
+                ]
+            },
+            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.'),
+            title: AI_CORE_PREFERENCES_TITLE,
+        }
+    }
+};
+
+export interface ChatToolConfiguration {
+    [TOOL_CONFIRMATION_PREFERENCE]: { [toolId: string]: ToolConfirmationMode };
+}
+
+export const ChatToolPreferenceContribution = Symbol('ChatToolPreferenceContribution');
+export const ChatToolPreferences = Symbol('ChatToolPreferences');
+export type ChatToolPreferences = PreferenceProxy<ChatToolConfiguration>;
+
+export function createChatToolPreferences(preferences: PreferenceService, schema: PreferenceSchema = chatToolPreferences): ChatToolPreferences {
+    return createPreferenceProxy(preferences, schema);
+}
+
+export function bindChatToolPreferences(bind: interfaces.Bind): void {
+    bind(ChatToolPreferences).toDynamicValue((ctx: interfaces.Context) => {
+        const preferences = ctx.container.get<PreferenceService>(PreferenceService);
+        const contribution = ctx.container.get<PreferenceContribution>(ChatToolPreferenceContribution);
+        return createChatToolPreferences(preferences, contribution.schema);
+    }).inSingletonScope();
+    bind(ChatToolPreferenceContribution).toConstantValue({ schema: chatToolPreferences });
+    bind(PreferenceContribution).toService(ChatToolPreferenceContribution);
+}
+
+/**
+ * Utility class to manage tool confirmation settings
+ */
+@injectable()
+export class ToolConfirmationManager {
+    @inject(ChatToolPreferences)
+    protected readonly preferences: ChatToolPreferences;
+
+    @inject(PreferenceService)
+    protected readonly preferenceService: PreferenceService;
+
+    // In-memory session overrides (not persisted), per chat
+    protected sessionOverrides: Map<string, Map<string, ToolConfirmationMode>> = new Map();
+
+    /**
+     * Get the confirmation mode for a specific tool, considering session overrides first (per chat)
+     */
+    getConfirmationMode(toolId: string, chatId: string): ToolConfirmationMode {
+        const chatMap = this.sessionOverrides.get(chatId);
+        if (chatMap && chatMap.has(toolId)) {
+            return chatMap.get(toolId)!;
+        }
+        const toolConfirmation = this.preferences[TOOL_CONFIRMATION_PREFERENCE];
+        if (toolConfirmation[toolId]) {
+            return toolConfirmation[toolId];
+        }
+        if (toolConfirmation['*']) {
+            return toolConfirmation['*'];
+        }
+        return ToolConfirmationMode.YOLO; // Default to YOLO
+    }
+
+    /**
+     * Set the confirmation mode for a specific tool (persisted)
+     */
+    setConfirmationMode(toolId: string, mode: ToolConfirmationMode): void {
+        const current = this.preferences[TOOL_CONFIRMATION_PREFERENCE] || {};
+        // Determine the global default (star entry), or fallback to schema default
+        let starMode = current['*'];
+        if (starMode === undefined) {
+            starMode = ToolConfirmationMode.YOLO;
+        }
+        if (mode === starMode) {
+            // Remove the toolId entry if it exists
+            if (toolId in current) {
+                const { [toolId]: _, ...rest } = current;
+                this.preferenceService.updateValue(TOOL_CONFIRMATION_PREFERENCE, rest);
+            }
+            // else, nothing to update
+        } else {
+            // Set or update the toolId entry
+            const updated = { ...current, [toolId]: mode };
+            this.preferenceService.updateValue(TOOL_CONFIRMATION_PREFERENCE, updated);
+        }
+    }
+
+    /**
+     * Set the confirmation mode for a specific tool for this session only (not persisted, per chat)
+     */
+    setSessionConfirmationMode(toolId: string, mode: ToolConfirmationMode, chatId: string): void {
+        let chatMap = this.sessionOverrides.get(chatId);
+        if (!chatMap) {
+            chatMap = new Map();
+            this.sessionOverrides.set(chatId, chatMap);
+        }
+        chatMap.set(toolId, mode);
+    }
+
+    /**
+     * Clear all session overrides for a specific chat, or all if no chatId is given
+     */
+    clearSessionOverrides(chatId?: string): void {
+        if (chatId) {
+            this.sessionOverrides.delete(chatId);
+        } else {
+            this.sessionOverrides.clear();
+        }
+    }
+
+    /**
+     * Get all tool confirmation settings
+     */
+    getAllConfirmationSettings(): { [toolId: string]: ToolConfirmationMode } {
+        return this.preferences[TOOL_CONFIRMATION_PREFERENCE] || {};
+    }
+
+    resetAllConfirmationModeSettings(): void {
+        const current = this.preferences[TOOL_CONFIRMATION_PREFERENCE] || {};
+        if ('*' in current) {
+            this.preferenceService.updateValue(TOOL_CONFIRMATION_PREFERENCE, { '*': current['*'] });
+        } else {
+            this.preferenceService.updateValue(TOOL_CONFIRMATION_PREFERENCE, {});
+        }
+    }
+}

package/src/browser/chat-tool-request-service.ts

@@ -0,0 +1,93 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { ToolRequest } from '@theia/ai-core';
+import { injectable, inject } from '@theia/core/shared/inversify';
+import { ChatToolRequestService, ChatToolRequest } from '../common/chat-tool-request-service';
+import { MutableChatRequestModel, ToolCallChatResponseContent } from '../common/chat-model';
+import { ToolConfirmationManager, ToolConfirmationMode, ChatToolPreferences } from './chat-tool-preferences';
+
+/**
+ * Frontend-specific implementation of ChatToolRequestService that handles tool confirmation
+ */
+@injectable()
+export class FrontendChatToolRequestService extends ChatToolRequestService {
+
+    @inject(ToolConfirmationManager)
+    protected readonly confirmationManager: ToolConfirmationManager;
+
+    @inject(ChatToolPreferences)
+    protected readonly preferences: ChatToolPreferences;
+
+    protected override toChatToolRequest(toolRequest: ToolRequest, request: MutableChatRequestModel): ChatToolRequest {
+        const confirmationMode = this.confirmationManager.getConfirmationMode(toolRequest.id, request.session.id);
+
+        return {
+            ...toolRequest,
+            handler: async (arg_string: string) => {
+                switch (confirmationMode) {
+                    case ToolConfirmationMode.DISABLED:
+                        return { denied: true, message: `Tool ${toolRequest.id} is disabled` };
+
+                    case ToolConfirmationMode.YOLO:
+                        // Execute immediately without confirmation
+                        return toolRequest.handler(arg_string, request);
+
+                    case ToolConfirmationMode.CONFIRM:
+                    default:
+                        // Create confirmation requirement
+                        const toolCallContent = this.findToolCallContent(toolRequest, arg_string, request);
+                        const confirmed = await toolCallContent.confirmed;
+
+                        if (confirmed) {
+                            return toolRequest.handler(arg_string, request);
+                        } else {
+                            // Return an object indicating the user denied the tool execution
+                            // instead of throwing an error
+                            return { denied: true, message: `Tool execution denied by user: ${toolRequest.id}` };
+                        }
+                }
+            }
+        };
+    }
+
+    /**
+     * Find existing tool call content or create a new one for confirmation tracking
+     *
+     * Looks for ToolCallChatResponseContent nodes where the name field matches the toolRequest id.
+     * Starts from the back of the content array to find the most recent match.
+     */
+    protected findToolCallContent(
+        toolRequest: ToolRequest,
+        arguments_: string,
+        request: MutableChatRequestModel
+    ): ToolCallChatResponseContent {
+        // Look for existing tool call content with matching ID
+        const response = request.response.response;
+        const contentArray = response.content;
+
+        // Start from the end of the array and find the first match
+        for (let i = contentArray.length - 1; i >= 0; i--) {
+            const content = contentArray[i];
+            if (ToolCallChatResponseContent.is(content) &&
+                content.name === toolRequest.id) {
+                return content;
+            }
+        }
+
+        throw new Error(`Tool call content for tool ${toolRequest.id} not found in the response`);
+    }
+}

package/src/browser/frontend-chat-service.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { inject, injectable } from '@theia/core/shared/inversify';
-import { ChangeSet, ChatAgent, ChatAgentLocation, ChatServiceImpl, ChatSession, ParsedChatRequest, SessionOptions } from '../common';
+import { ChatAgent, ChatAgentLocation, ChatChangeEvent, ChatServiceImpl, ChatSession, ParsedChatRequest, SessionOptions } from '../common';
 import { PreferenceService } from '@theia/core/lib/browser';
 import { DEFAULT_CHAT_AGENT_PREF, PIN_CHAT_AGENT_PREF } from './ai-chat-preferences';
 import { ChangeSetFileService } from './change-set-file-service';
@@ -68,11 +68,8 @@ export class FrontendChatServiceImpl extends ChatServiceImpl {
     override createSession(location?: ChatAgentLocation, options?: SessionOptions, pinnedAgent?: ChatAgent): ChatSession {
         const session = super.createSession(location, options, pinnedAgent);
         session.model.onDidChange(event => {
-            const changeSet = (event as { changeSet?: ChangeSet }).changeSet;
-            if (event.kind === 'removeChangeSet') {
-                this.changeSetFileService.closeDiffsForSession(session.id);
-            } else if (changeSet) {
-                this.changeSetFileService.closeDiffsForSession(session.id, changeSet.getElements().map(({ uri }) => uri));
+            if (ChatChangeEvent.isChangeSetEvent(event)) {
+                this.changeSetFileService.closeDiffsForSession(session.id, session.model.changeSet.getElements().map(({ uri }) => uri));
             }
         });
         return session;

package/src/common/change-set.ts

@@ -0,0 +1,197 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { ArrayUtils, Disposable, Emitter, Event, URI } from '@theia/core';
+
+export interface ChangeSetElement {
+    readonly uri: URI;
+
+    onDidChange?: Event<void>
+    readonly name?: string;
+    readonly icon?: string;
+    readonly additionalInfo?: string;
+
+    readonly state?: 'pending' | 'applied' | 'stale';
+    readonly type?: 'add' | 'modify' | 'delete';
+    readonly data?: { [key: string]: unknown };
+
+    /** Called when an element is shown in the UI */
+    onShow?(): void;
+    /** Called when an element is hidden in the UI */
+    onHide?(): void;
+    open?(): Promise<void>;
+    openChange?(): Promise<void>;
+    apply?(): Promise<void>;
+    revert?(): Promise<void>;
+    dispose?(): void;
+}
+
+export interface ChatUpdateChangeSetEvent {
+    kind: 'updateChangeSet';
+    elements?: ChangeSetElement[];
+    title?: string;
+}
+
+export interface ChangeSetChangeEvent {
+    title?: string;
+    added?: URI[],
+    removed?: URI[],
+    modified?: URI[],
+    /** Fired when only the state of a given element changes, not its contents */
+    state?: URI[],
+}
+
+export interface ChangeSet extends Disposable {
+    onDidChange: Event<ChatUpdateChangeSetEvent>;
+    readonly title: string;
+    setTitle(title: string): void;
+    getElements(): ChangeSetElement[];
+    /**
+     * Find an element by URI.
+     * @param uri The URI to look for.
+     * @returns The element with the given URI, or undefined if not found.
+     */
+    getElementByURI(uri: URI): ChangeSetElement | undefined;
+    /** @returns true if addition produces a change; false otherwise. */
+    addElements(...elements: ChangeSetElement[]): boolean;
+    setElements(...elements: ChangeSetElement[]): void;
+    /** @returns true if deletion produces a change; false otherwise. */
+    removeElements(...uris: URI[]): boolean;
+    dispose(): void;
+}
+
+export class ChangeSetImpl implements ChangeSet {
+    /** @param changeSets ordered from tip to root. */
+    static combine(changeSets: Iterable<ChangeSetImpl>): Map<string, ChangeSetElement | undefined> {
+        const result = new Map<string, ChangeSetElement | undefined>();
+        for (const next of changeSets) {
+            next._elements.forEach((value, key) => !result.has(key) && result.set(key, value));
+            // Break at the first element whose values were set, not just changed through addition and deletion.
+            if (next.hasBeenSet) {
+                break;
+            }
+        }
+
+        return result;
+    }
+
+    protected readonly _onDidChangeEmitter = new Emitter<ChatUpdateChangeSetEvent>();
+    onDidChange: Event<ChatUpdateChangeSetEvent> = this._onDidChangeEmitter.event;
+    protected readonly _onDidChangeContentsEmitter = new Emitter<ChangeSetChangeEvent>();
+    onDidChangeContents: Event<ChangeSetChangeEvent> = this._onDidChangeContentsEmitter.event;
+
+    protected hasBeenSet = false;
+    protected _elements = new Map<string, ChangeSetElement | undefined>();
+    protected _title = 'Suggested Changes';
+    get title(): string {
+        return this._title;
+    }
+
+    constructor(elements: ChangeSetElement[] = []) {
+        this.addElements(...elements);
+    }
+
+    getElements(): ChangeSetElement[] {
+        return ArrayUtils.coalesce(Array.from(this._elements.values()));
+    }
+
+    /** Will replace any element that is already present, using URI as identity criterion. */
+    addElements(...elements: ChangeSetElement[]): boolean {
+        const added: URI[] = [];
+        const modified: URI[] = [];
+        elements.forEach(element => {
+            if (this.doAdd(element)) {
+                modified.push(element.uri);
+            } else {
+                added.push(element.uri);
+            }
+        });
+        this.notifyChange({ added, modified });
+        return !!(added.length || modified.length);
+    }
+
+    setTitle(title: string): void {
+        this._title = title;
+        this.notifyChange({ title });
+    }
+
+    protected doAdd(element: ChangeSetElement): boolean {
+        const id = element.uri.toString();
+        const existing = this._elements.get(id);
+        existing?.dispose?.();
+        this._elements.set(id, element);
+        element.onDidChange?.(() => this.notifyChange({ state: [element.uri] }));
+        return !!existing;
+    }
+
+    setElements(...elements: ChangeSetElement[]): void {
+        this.hasBeenSet = true;
+        const added = [];
+        const modified = [];
+        const removed = [];
+        const toHandle = new Set(...this._elements.keys());
+        for (const element of elements) {
+            toHandle.delete(element.uri.toString());
+            if (this.doAdd(element)) {
+                added.push(element.uri);
+            } else {
+                modified.push(element.uri);
+            }
+        }
+        for (const toDelete of toHandle) {
+            const uri = new URI(toDelete);
+            if (this.doDelete(uri)) {
+                removed.push(uri);
+            }
+        }
+        this.notifyChange({ added, modified, removed });
+    }
+
+    removeElements(...uris: URI[]): boolean {
+        const removed: URI[] = [];
+        for (const uri of uris) {
+            if (this.doDelete(uri)) {
+                removed.push(uri);
+            }
+        }
+        this.notifyChange({ removed });
+        return !!removed.length;
+    }
+
+    getElementByURI(uri: URI): ChangeSetElement | undefined {
+        return this._elements.get(uri.toString());
+    }
+
+    protected doDelete(uri: URI): boolean {
+        const id = uri.toString();
+        const delendum = this._elements.get(id);
+        if (delendum) {
+            delendum.dispose?.();
+        }
+        this._elements.set(id, undefined);
+        return !!delendum;
+    }
+
+    protected notifyChange(change: ChangeSetChangeEvent): void {
+        this._onDidChangeContentsEmitter.fire(change);
+        this._onDidChangeEmitter.fire({ kind: 'updateChangeSet', elements: this.getElements(), title: this.title });
+    }
+
+    dispose(): void {
+        this._onDidChangeEmitter.dispose();
+        this._elements.forEach(element => element?.dispose?.());
+    }
+}

package/src/common/chat-agents.ts

@@ -61,6 +61,7 @@ import {
     ToolCallChatResponseContentImpl,
     ChatRequestModel,
     ThinkingChatResponseContentImpl,
+    ErrorChatResponseContent,
 } from './chat-model';
 import { parseContents } from './parse-contents';
 import { DefaultResponseContentFactory, ResponseContentMatcher, ResponseContentMatcherProvider } from './response-content-matcher';
@@ -218,6 +219,7 @@ export abstract class AbstractChatAgent implements ChatAgent {
     };
 
     protected handleError(request: MutableChatRequestModel, error: Error): void {
+        console.error('Error handling chat interaction:', error);
         request.response.response.addContent(new ErrorChatResponseContentImpl(error));
         request.response.error(error);
     }
@@ -258,17 +260,19 @@ export abstract class AbstractChatAgent implements ChatAgent {
                 text: text,
             });
             if (request.response.isComplete || includeResponseInProgress) {
-                const responseMessages: LanguageModelMessage[] = request.response.response.content.flatMap(c => {
-                    if (ChatResponseContent.hasToLanguageModelMessage(c)) {
-                        return c.toLanguageModelMessage();
-                    }
-
-                    return {
-                        actor: 'ai',
-                        type: 'text',
-                        text: c.asString?.() ?? c.asDisplayString?.() ?? '',
-                    } as TextMessage;
-                });
+                const responseMessages: LanguageModelMessage[] = request.response.response.content
+                    .filter(c => !ErrorChatResponseContent.is(c))
+                    .flatMap(c => {
+                        if (ChatResponseContent.hasToLanguageModelMessage(c)) {
+                            return c.toLanguageModelMessage();
+                        }
+
+                        return {
+                            actor: 'ai',
+                            type: 'text',
+                            text: c.asString?.() ?? c.asDisplayString?.() ?? '',
+                        } as TextMessage;
+                    });
                 messages.push(...responseMessages);
             }
             return messages;