@theia/ai-chat-ui 1.61.0-next.8 → 1.61.0

package/src/browser/ai-chat-ui-contribution.ts

@@ -15,9 +15,13 @@
 // *****************************************************************************
 
 import { inject, injectable } from '@theia/core/shared/inversify';
-import { CommandRegistry, isOSX, nls, QuickInputButton, QuickInputService, QuickPickItem } from '@theia/core';
+import { CommandRegistry, Emitter, isOSX, MessageService, nls, QuickInputButton, QuickInputService, QuickPickItem } from '@theia/core';
 import { Widget } from '@theia/core/lib/browser';
-import { AI_CHAT_NEW_CHAT_WINDOW_COMMAND, AI_CHAT_SHOW_CHATS_COMMAND, ChatCommands } from './chat-view-commands';
+import {
+    AI_CHAT_NEW_CHAT_WINDOW_COMMAND,
+    AI_CHAT_SHOW_CHATS_COMMAND,
+    ChatCommands
+} from './chat-view-commands';
 import { ChatAgentLocation, ChatService } from '@theia/ai-chat';
 import { AbstractViewContribution } from '@theia/core/lib/browser/shell/view-contribution';
 import { TabBarToolbarContribution, TabBarToolbarRegistry } from '@theia/core/lib/browser/shell/tab-bar-toolbar';
@@ -28,6 +32,10 @@ import { formatDistance } from 'date-fns';
 import * as locales from 'date-fns/locale';
 import { AI_SHOW_SETTINGS_COMMAND } from '@theia/ai-core/lib/browser';
 import { OPEN_AI_HISTORY_VIEW } from '@theia/ai-history/lib/browser/ai-history-contribution';
+import { ChatNodeToolbarCommands } from './chat-node-toolbar-action-contribution';
+import { isEditableRequestNode, type EditableRequestNode } from './chat-tree-view';
+import { TASK_CONTEXT_VARIABLE } from '@theia/ai-chat/lib/browser/task-context-variable';
+import { TaskContextService } from '@theia/ai-chat/lib/browser/task-context-service';
 
 export const AI_CHAT_TOGGLE_COMMAND_ID = 'aiChat:toggle';
 
@@ -38,6 +46,10 @@ export class AIChatContribution extends AbstractViewContribution<ChatViewWidget>
     protected readonly chatService: ChatService;
     @inject(QuickInputService)
     protected readonly quickInputService: QuickInputService;
+    @inject(TaskContextService)
+    protected readonly taskContextService: TaskContextService;
+    @inject(MessageService)
+    protected readonly messageService: MessageService;
 
     protected static readonly RENAME_CHAT_BUTTON: QuickInputButton = {
         iconClass: 'codicon-edit',
@@ -83,14 +95,66 @@ export class AIChatContribution extends AbstractViewContribution<ChatViewWidget>
             })
         });
         registry.registerCommand(AI_CHAT_NEW_CHAT_WINDOW_COMMAND, {
-            execute: () => this.chatService.createSession(ChatAgentLocation.Panel, { focus: true }),
-            isEnabled: widget => this.withWidget(widget, () => true),
+            execute: () => this.openView().then(() => this.chatService.createSession(ChatAgentLocation.Panel, { focus: true })),
             isVisible: widget => this.withWidget(widget, () => true),
         });
+        registry.registerCommand(ChatCommands.AI_CHAT_NEW_WITH_TASK_CONTEXT, {
+            execute: async () => {
+                const activeSession = this.chatService.getActiveSession();
+                const id = await this.summarizeActiveSession();
+                if (!id || !activeSession) { return; }
+                const newSession = this.chatService.createSession(ChatAgentLocation.Panel, { focus: true }, activeSession.pinnedAgent);
+                const summaryVariable = { variable: TASK_CONTEXT_VARIABLE, arg: id };
+                newSession.model.context.addVariables(summaryVariable);
+            },
+            isVisible: () => false
+        });
+        registry.registerCommand(ChatCommands.AI_CHAT_SUMMARIZE_CURRENT_SESSION, {
+            execute: async () => this.summarizeActiveSession(),
+            isVisible: widget => {
+                if (widget && !this.withWidget(widget)) { return false; }
+                const activeSession = this.chatService.getActiveSession();
+                return activeSession?.model.location === ChatAgentLocation.Panel
+                    && !this.taskContextService.hasSummary(activeSession);
+            },
+            isEnabled: widget => {
+                if (widget && !this.withWidget(widget)) { return false; }
+                const activeSession = this.chatService.getActiveSession();
+                return activeSession?.model.location === ChatAgentLocation.Panel
+                    && !activeSession.model.isEmpty()
+                    && !this.taskContextService.hasSummary(activeSession);
+            }
+        });
+        registry.registerCommand(ChatCommands.AI_CHAT_OPEN_SUMMARY_FOR_CURRENT_SESSION, {
+            execute: async () => {
+                const id = await this.summarizeActiveSession();
+                if (!id) { return; }
+                await this.taskContextService.open(id);
+            },
+            isVisible: widget => {
+                if (widget && !this.withWidget(widget)) { return false; }
+                const activeSession = this.chatService.getActiveSession();
+                return !!activeSession && this.taskContextService.hasSummary(activeSession);
+            }
+        });
         registry.registerCommand(AI_CHAT_SHOW_CHATS_COMMAND, {
             execute: () => this.selectChat(),
-            isEnabled: widget => this.withWidget(widget, () => true) && this.chatService.getSessions().length > 1,
-            isVisible: widget => this.withWidget(widget, () => true)
+            isEnabled: widget => this.withWidget(widget) && this.chatService.getSessions().length > 1,
+            isVisible: widget => this.withWidget(widget)
+        });
+        registry.registerCommand(ChatNodeToolbarCommands.EDIT, {
+            isEnabled: node => isEditableRequestNode(node) && !node.request.isEditing,
+            isVisible: node => isEditableRequestNode(node) && !node.request.isEditing,
+            execute: (node: EditableRequestNode) => {
+                node.request.enableEdit();
+            }
+        });
+        registry.registerCommand(ChatNodeToolbarCommands.CANCEL, {
+            isEnabled: node => isEditableRequestNode(node) && node.request.isEditing,
+            isVisible: node => isEditableRequestNode(node) && node.request.isEditing,
+            execute: (node: EditableRequestNode) => {
+                node.request.cancelEdit();
+            }
         });
     }
 
@@ -123,6 +187,19 @@ export class AIChatContribution extends AbstractViewContribution<ChatViewWidget>
             priority: 1,
             isVisible: widget => this.withWidget(widget),
         });
+        const sessionSummarizibilityChangedEmitter = new Emitter<void>();
+        this.taskContextService.onDidChange(() => sessionSummarizibilityChangedEmitter.fire());
+        this.chatService.onSessionEvent(event => event.type === 'activeChange' && sessionSummarizibilityChangedEmitter.fire());
+        registry.registerItem({
+            id: 'chat-view.' + ChatCommands.AI_CHAT_SUMMARIZE_CURRENT_SESSION.id,
+            command: ChatCommands.AI_CHAT_SUMMARIZE_CURRENT_SESSION.id,
+            onDidChange: sessionSummarizibilityChangedEmitter.event
+        });
+        registry.registerItem({
+            id: 'chat-view.' + ChatCommands.AI_CHAT_OPEN_SUMMARY_FOR_CURRENT_SESSION.id,
+            command: ChatCommands.AI_CHAT_OPEN_SUMMARY_FOR_CURRENT_SESSION.id,
+            onDidChange: sessionSummarizibilityChangedEmitter.event
+        });
     }
 
     protected async selectChat(sessionId?: string): Promise<void> {
@@ -211,6 +288,16 @@ export class AIChatContribution extends AbstractViewContribution<ChatViewWidget>
     canExtractChatView(chatView: ChatViewWidget): boolean {
         return !chatView.secondaryWindow;
     }
+
+    protected async summarizeActiveSession(): Promise<string | undefined> {
+        const activeSession = this.chatService.getActiveSession();
+        if (!activeSession) { return; }
+        return this.taskContextService.summarize(activeSession).catch(err => {
+            console.warn('Error while summarizing session:', err);
+            this.messageService.error('Unable to summarize current session. Please confirm that the summary agent is not disabled.');
+            return undefined;
+        });
+    }
 }
 
 function getDateFnsLocale(): locales.Locale {

package/src/browser/ai-chat-ui-frontend-module.ts

@@ -22,7 +22,7 @@ import { ContainerModule, interfaces } from '@theia/core/shared/inversify';
 import { EditorSelectionResolver } from '@theia/editor/lib/browser/editor-manager';
 import { AIChatContribution } from './ai-chat-ui-contribution';
 import { AIChatInputConfiguration, AIChatInputWidget } from './chat-input-widget';
-import { ChatNodeToolbarActionContribution } from './chat-node-toolbar-action-contribution';
+import { ChatNodeToolbarActionContribution, DefaultChatNodeToolbarActionContribution } from './chat-node-toolbar-action-contribution';
 import { ChatResponsePartRenderer } from './chat-response-part-renderer';
 import {
     CodePartRenderer,
@@ -52,6 +52,7 @@ import { ChatViewWidgetToolbarContribution } from './chat-view-widget-toolbar-co
 import { ContextVariablePicker } from './context-variable-picker';
 import { ChangeSetActionRenderer, ChangeSetActionService } from './change-set-actions/change-set-action-service';
 import { ChangeSetAcceptAction } from './change-set-actions/change-set-accept-action';
+import { AIChatTreeInputArgs, AIChatTreeInputConfiguration, AIChatTreeInputFactory, AIChatTreeInputWidget } from './chat-tree-view/chat-view-tree-input-widget';
 
 export default new ContainerModule((bind, _unbind, _isBound, rebind) => {
     bindViewContribution(bind, AIChatContribution);
@@ -64,8 +65,9 @@ export default new ContainerModule((bind, _unbind, _isBound, rebind) => {
     bind(AIChatInputWidget).toSelf();
     bind(AIChatInputConfiguration).toConstantValue({
         showContext: true,
-        showPinnedAgent: true
-    });
+        showPinnedAgent: true,
+        showChangeSet: true
+    } satisfies AIChatInputConfiguration);
     bind(WidgetFactory).toDynamicValue(({ container }) => ({
         id: AIChatInputWidget.ID,
         createWidget: () => container.get(AIChatInputWidget)
@@ -79,6 +81,30 @@ export default new ContainerModule((bind, _unbind, _isBound, rebind) => {
         createWidget: () => container.get(ChatViewTreeWidget)
     })).inSingletonScope();
 
+    bind(AIChatTreeInputFactory).toFactory(ctx => (args: AIChatTreeInputArgs) => {
+        const container = ctx.container.createChild();
+        container.bind(AIChatTreeInputArgs).toConstantValue(args);
+        container.bind(AIChatTreeInputConfiguration).toConstantValue({
+            showContext: true,
+            showPinnedAgent: true,
+            showChangeSet: false
+        } satisfies AIChatInputConfiguration);
+        container.bind(AIChatTreeInputWidget).toSelf().inSingletonScope();
+        const widget = container.get(AIChatTreeInputWidget);
+        const noOp = () => { };
+        widget.node.classList.add('chat-input-widget');
+        widget.chatModel = args.node.request.session;
+        widget.initialValue = args.initialValue;
+        widget.setEnabled(true);
+        widget.onQuery = args.onQuery;
+        // We need to set those values here, otherwise the widget will throw an error
+        widget.onUnpin = args.onUnpin ?? noOp;
+        widget.onCancel = args.onCancel ?? noOp;
+        widget.onDeleteChangeSet = args.onDeleteChangeSet ?? noOp;
+        widget.onDeleteChangeSetElement = args.onDeleteChangeSetElement ?? noOp;
+        return widget;
+    });
+
     bind(ContextVariablePicker).toSelf().inSingletonScope();
 
     bind(ChatResponsePartRenderer).to(HorizontalLayoutPartRenderer).inSingletonScope();
@@ -115,6 +141,8 @@ export default new ContainerModule((bind, _unbind, _isBound, rebind) => {
     bind(ChangeSetActionRenderer).toService(ChangeSetAcceptAction);
 
     bindContributionProvider(bind, ChatNodeToolbarActionContribution);
+    bind(DefaultChatNodeToolbarActionContribution).toSelf().inSingletonScope();
+    bind(ChatNodeToolbarActionContribution).toService(DefaultChatNodeToolbarActionContribution);
 });
 
 function bindChatViewWidget(bind: interfaces.Bind): void {

package/src/browser/chat-input-agent-suggestions.tsx

@@ -0,0 +1,85 @@
+// *****************************************************************************
+// 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 * as React from '@theia/core/shared/react';
+import { DeclaredEventsEventListenerObject, useMarkdownRendering } from './chat-response-renderer/markdown-part-renderer';
+import { OpenerService } from '@theia/core/lib/browser';
+import { ChatSuggestion, ChatSuggestionCallback } from '@theia/ai-chat';
+import { MarkdownString } from '@theia/core/lib/common/markdown-rendering';
+
+interface ChatInputAgentSuggestionsProps {
+    suggestions: readonly ChatSuggestion[];
+    opener: OpenerService;
+}
+
+function getText(suggestion: ChatSuggestion): string {
+    if (typeof suggestion === 'string') { return suggestion; }
+    if ('value' in suggestion) { return suggestion.value; }
+    if (typeof suggestion.content === 'string') { return suggestion.content; }
+    return suggestion.content.value;
+}
+
+function getContent(suggestion: ChatSuggestion): string | MarkdownString {
+    if (typeof suggestion === 'string') { return suggestion; }
+    if ('value' in suggestion) { return suggestion; }
+    return suggestion.content;
+}
+
+export const ChatInputAgentSuggestions: React.FC<ChatInputAgentSuggestionsProps> = ({ suggestions, opener }) => (
+    !!suggestions?.length && <div className="chat-agent-suggestions">
+        {suggestions.map(suggestion => <ChatInputAgentSuggestion
+            key={getText(suggestion)}
+            suggestion={suggestion}
+            opener={opener}
+            handler={ChatSuggestionCallback.is(suggestion) ? new ChatSuggestionClickHandler(suggestion) : undefined}
+        />)}
+    </div>
+);
+
+interface ChatInputAgestSuggestionProps {
+    suggestion: ChatSuggestion;
+    opener: OpenerService;
+    handler?: DeclaredEventsEventListenerObject;
+}
+
+const ChatInputAgentSuggestion: React.FC<ChatInputAgestSuggestionProps> = ({ suggestion, opener, handler }) => {
+    const ref = useMarkdownRendering(getContent(suggestion), opener, true, handler);
+    return <div className="chat-agent-suggestion" style={(!handler || ChatSuggestionCallback.containsCallbackLink(suggestion)) ? undefined : { cursor: 'pointer' }} ref={ref} />;
+};
+
+class ChatSuggestionClickHandler implements DeclaredEventsEventListenerObject {
+    constructor(protected readonly suggestion: ChatSuggestionCallback) { }
+    handleEvent(event: Event): boolean {
+        const { target, currentTarget } = event;
+        if (event.type !== 'click' || !(target instanceof Element)) { return false; }
+        const link = target.closest('a[href^="_callback"]');
+        if (link) {
+            this.suggestion.callback();
+            return true;
+        }
+        if (!(currentTarget instanceof Element)) {
+            this.suggestion.callback();
+            return true;
+        }
+        const containedLink = currentTarget.querySelector('a[href^="_callback"]');
+        // Whole body should count.
+        if (!containedLink) {
+            this.suggestion.callback();
+            return true;
+        }
+        return false;
+    }
+}