@theia/ai-chat-ui 1.67.0-next.56 → 1.67.0-next.59

package/lib/browser/ai-chat-ui-contribution.d.ts

@@ -0,0 +1,66 @@
+import { CommandRegistry, MessageService, QuickInputButton, QuickInputService, QuickPickItem } from '@theia/core';
+import { ILogger } from '@theia/core/lib/common/logger';
+import { Widget } from '@theia/core/lib/browser';
+import { ChatAgent, ChatService } from '@theia/ai-chat';
+import { ChatAgentService } from '@theia/ai-chat/lib/common/chat-agent-service';
+import { EditorManager } from '@theia/editor/lib/browser/editor-manager';
+import { AbstractViewContribution } from '@theia/core/lib/browser/shell/view-contribution';
+import { TabBarToolbarContribution, TabBarToolbarRegistry } from '@theia/core/lib/browser/shell/tab-bar-toolbar';
+import { ChatViewWidget } from './chat-view-widget';
+import { SecondaryWindowHandler } from '@theia/core/lib/browser/secondary-window-handler';
+import { AIActivationService } from '@theia/ai-core/lib/browser';
+import { TaskContextService } from '@theia/ai-chat/lib/browser/task-context-service';
+export declare const AI_CHAT_TOGGLE_COMMAND_ID = "aiChat:toggle";
+export declare class AIChatContribution extends AbstractViewContribution<ChatViewWidget> implements TabBarToolbarContribution {
+    protected readonly chatService: ChatService;
+    protected readonly quickInputService: QuickInputService;
+    protected readonly taskContextService: TaskContextService;
+    protected readonly messageService: MessageService;
+    protected readonly chatAgentService: ChatAgentService;
+    protected readonly editorManager: EditorManager;
+    protected readonly activationService: AIActivationService;
+    protected readonly logger: ILogger;
+    /**
+     * Store whether there are persisted sessions to make this information available in
+     * command enablement checks which are synchronous.
+     */
+    protected hasPersistedSessions: boolean;
+    protected static readonly RENAME_CHAT_BUTTON: QuickInputButton;
+    protected static readonly REMOVE_CHAT_BUTTON: QuickInputButton;
+    protected readonly secondaryWindowHandler: SecondaryWindowHandler;
+    constructor();
+    initialize(): void;
+    protected checkPersistedSessions(): Promise<void>;
+    registerCommands(registry: CommandRegistry): void;
+    registerToolbarItems(registry: TabBarToolbarRegistry): void;
+    protected selectChat(sessionId?: string): Promise<void>;
+    protected askForChatSession(): Promise<QuickPickItem | undefined>;
+    protected withWidget(widget?: Widget | undefined, predicate?: (output: ChatViewWidget) => boolean): boolean | false;
+    protected extractChatView(chatView: ChatViewWidget): void;
+    canExtractChatView(chatView: ChatViewWidget): boolean;
+    protected summarizeActiveSession(): Promise<string | undefined>;
+    /**
+     * Prompts the user to select a chat agent
+     * @returns The selected agent or undefined if cancelled
+     */
+    /**
+     * Prompts the user to select a chat agent with an optional default (pre-selected) agent.
+     * @param defaultAgentId The id of the agent to pre-select, if present
+     * @returns The selected agent or undefined if cancelled
+     */
+    protected selectAgent(defaultAgentId?: string): Promise<ChatAgent | undefined>;
+    /**
+     * Prompts the user to select a task context with special marking for currently opened files
+     * @returns The selected task context ID or undefined if cancelled
+     */
+    protected selectTaskContextWithMarking(): Promise<string | undefined>;
+    /**
+     * Returns information about task context files that are currently opened
+     * @returns Object with arrays of opened context IDs and the active context ID
+     */
+    protected getOpenedTaskContextFiles(): {
+        openedIds: string[];
+        activeId?: string;
+    };
+}
+//# sourceMappingURL=ai-chat-ui-contribution.d.ts.map

package/lib/browser/ai-chat-ui-contribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-chat-ui-contribution.d.ts","sourceRoot":"","sources":["../../src/browser/ai-chat-ui-contribution.ts"],"names":[],"mappings":"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"}

package/lib/browser/ai-chat-ui-contribution.js

@@ -0,0 +1,587 @@
+"use strict";
+// *****************************************************************************
+// Copyright (C) 2024 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
+// *****************************************************************************
+var AIChatContribution_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIChatContribution = exports.AI_CHAT_TOGGLE_COMMAND_ID = void 0;
+const tslib_1 = require("tslib");
+const inversify_1 = require("@theia/core/shared/inversify");
+const core_1 = require("@theia/core");
+const logger_1 = require("@theia/core/lib/common/logger");
+const chat_view_commands_1 = require("./chat-view-commands");
+const ai_chat_1 = require("@theia/ai-chat");
+const chat_agent_service_1 = require("@theia/ai-chat/lib/common/chat-agent-service");
+const editor_manager_1 = require("@theia/editor/lib/browser/editor-manager");
+const view_contribution_1 = require("@theia/core/lib/browser/shell/view-contribution");
+const chat_view_widget_1 = require("./chat-view-widget");
+const promise_util_1 = require("@theia/core/lib/common/promise-util");
+const secondary_window_handler_1 = require("@theia/core/lib/browser/secondary-window-handler");
+const date_fns_1 = require("date-fns");
+const locales = require("date-fns/locale");
+const browser_1 = require("@theia/ai-core/lib/browser");
+const chat_node_toolbar_action_contribution_1 = require("./chat-node-toolbar-action-contribution");
+const chat_tree_view_1 = require("./chat-tree-view");
+const task_context_variable_1 = require("@theia/ai-chat/lib/browser/task-context-variable");
+const task_context_service_1 = require("@theia/ai-chat/lib/browser/task-context-service");
+exports.AI_CHAT_TOGGLE_COMMAND_ID = 'aiChat:toggle';
+let AIChatContribution = AIChatContribution_1 = class AIChatContribution extends view_contribution_1.AbstractViewContribution {
+    constructor() {
+        super({
+            widgetId: chat_view_widget_1.ChatViewWidget.ID,
+            widgetName: chat_view_widget_1.ChatViewWidget.LABEL,
+            defaultWidgetOptions: {
+                area: 'right',
+                rank: 100
+            },
+            toggleCommandId: exports.AI_CHAT_TOGGLE_COMMAND_ID,
+            toggleKeybinding: core_1.isOSX ? 'ctrl+cmd+i' : 'ctrl+alt+i'
+        });
+        /**
+         * Store whether there are persisted sessions to make this information available in
+         * command enablement checks which are synchronous.
+         */
+        this.hasPersistedSessions = false;
+    }
+    initialize() {
+        this.chatService.onSessionEvent(event => {
+            if (!(0, ai_chat_1.isActiveSessionChangedEvent)(event)) {
+                return;
+            }
+            if (event.focus) {
+                this.openView({ activate: true });
+            }
+        });
+        this.checkPersistedSessions();
+    }
+    async checkPersistedSessions() {
+        try {
+            const index = await this.chatService.getPersistedSessions();
+            this.hasPersistedSessions = Object.keys(index).length > 0;
+        }
+        catch (e) {
+            this.logger.error('Failed to check persisted AI sessions', e);
+            this.hasPersistedSessions = false;
+        }
+    }
+    registerCommands(registry) {
+        super.registerCommands(registry);
+        registry.registerCommand(chat_view_commands_1.ChatCommands.SCROLL_LOCK_WIDGET, {
+            isEnabled: widget => this.withWidget(widget, chatWidget => !chatWidget.isLocked),
+            isVisible: widget => this.withWidget(widget, chatWidget => !chatWidget.isLocked),
+            execute: widget => this.withWidget(widget, chatWidget => {
+                chatWidget.lock();
+                return true;
+            })
+        });
+        registry.registerCommand(chat_view_commands_1.ChatCommands.SCROLL_UNLOCK_WIDGET, {
+            isEnabled: widget => this.withWidget(widget, chatWidget => chatWidget.isLocked),
+            isVisible: widget => this.withWidget(widget, chatWidget => chatWidget.isLocked),
+            execute: widget => this.withWidget(widget, chatWidget => {
+                chatWidget.unlock();
+                return true;
+            })
+        });
+        registry.registerCommand(chat_view_commands_1.AI_CHAT_NEW_CHAT_WINDOW_COMMAND, {
+            execute: () => this.openView().then(() => this.chatService.createSession(ai_chat_1.ChatAgentLocation.Panel, { focus: true })),
+            isVisible: widget => this.activationService.isActive,
+            isEnabled: widget => this.activationService.isActive,
+        });
+        registry.registerCommand(chat_view_commands_1.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(ai_chat_1.ChatAgentLocation.Panel, { focus: true }, activeSession.pinnedAgent);
+                const summaryVariable = { variable: task_context_variable_1.TASK_CONTEXT_VARIABLE, arg: id };
+                newSession.model.context.addVariables(summaryVariable);
+            },
+            isVisible: () => false
+        });
+        registry.registerCommand(chat_view_commands_1.ChatCommands.AI_CHAT_SUMMARIZE_CURRENT_SESSION, {
+            execute: async () => this.summarizeActiveSession(),
+            isVisible: widget => {
+                if (!this.activationService.isActive) {
+                    return false;
+                }
+                if (widget && !this.withWidget(widget)) {
+                    return false;
+                }
+                const activeSession = this.chatService.getActiveSession();
+                return (activeSession === null || activeSession === void 0 ? void 0 : activeSession.model.location) === ai_chat_1.ChatAgentLocation.Panel
+                    && !this.taskContextService.hasSummary(activeSession);
+            },
+            isEnabled: widget => {
+                if (!this.activationService.isActive) {
+                    return false;
+                }
+                if (widget && !this.withWidget(widget)) {
+                    return false;
+                }
+                const activeSession = this.chatService.getActiveSession();
+                return (activeSession === null || activeSession === void 0 ? void 0 : activeSession.model.location) === ai_chat_1.ChatAgentLocation.Panel
+                    && !activeSession.model.isEmpty()
+                    && !this.taskContextService.hasSummary(activeSession);
+            }
+        });
+        registry.registerCommand(chat_view_commands_1.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 (!this.activationService.isActive) {
+                    return false;
+                }
+                if (widget && !this.withWidget(widget)) {
+                    return false;
+                }
+                const activeSession = this.chatService.getActiveSession();
+                return !!activeSession && this.taskContextService.hasSummary(activeSession);
+            },
+            isEnabled: widget => {
+                if (!this.activationService.isActive) {
+                    return false;
+                }
+                return this.withWidget(widget, () => true);
+            }
+        });
+        registry.registerCommand(chat_view_commands_1.ChatCommands.AI_CHAT_INITIATE_SESSION_WITH_TASK_CONTEXT, {
+            execute: async () => {
+                const selectedContextId = await this.selectTaskContextWithMarking();
+                if (!selectedContextId) {
+                    return;
+                }
+                const selectedAgent = await this.selectAgent('Coder');
+                if (!selectedAgent) {
+                    return;
+                }
+                const newSession = this.chatService.createSession(ai_chat_1.ChatAgentLocation.Panel, { focus: true }, selectedAgent);
+                newSession.model.context.addVariables({ variable: task_context_variable_1.TASK_CONTEXT_VARIABLE, arg: selectedContextId });
+            },
+            isVisible: () => this.activationService.isActive,
+            isEnabled: () => this.activationService.isActive
+        });
+        registry.registerCommand(chat_view_commands_1.AI_CHAT_SHOW_CHATS_COMMAND, {
+            execute: () => this.selectChat(),
+            isEnabled: widget => {
+                if (!this.activationService.isActive || !this.withWidget(widget)) {
+                    return false;
+                }
+                // Enable if there are active sessions with titles OR persisted sessions
+                return this.chatService.getSessions().some(session => !!session.title) || this.hasPersistedSessions;
+            },
+            isVisible: widget => this.activationService.isActive && this.withWidget(widget)
+        });
+        registry.registerCommand(chat_node_toolbar_action_contribution_1.ChatNodeToolbarCommands.EDIT, {
+            isEnabled: node => (0, chat_tree_view_1.isEditableRequestNode)(node) && !node.request.isEditing,
+            isVisible: node => (0, chat_tree_view_1.isEditableRequestNode)(node) && !node.request.isEditing,
+            execute: (node) => {
+                node.request.enableEdit();
+            }
+        });
+        registry.registerCommand(chat_node_toolbar_action_contribution_1.ChatNodeToolbarCommands.CANCEL, {
+            isEnabled: node => (0, chat_tree_view_1.isEditableRequestNode)(node) && node.request.isEditing,
+            isVisible: node => (0, chat_tree_view_1.isEditableRequestNode)(node) && node.request.isEditing,
+            execute: (node) => {
+                node.request.cancelEdit();
+            }
+        });
+        registry.registerCommand(chat_node_toolbar_action_contribution_1.ChatNodeToolbarCommands.RETRY, {
+            isEnabled: node => (0, chat_tree_view_1.isResponseNode)(node) && (node.response.isError || node.response.isCanceled),
+            isVisible: node => (0, chat_tree_view_1.isResponseNode)(node) && (node.response.isError || node.response.isCanceled),
+            execute: async (node) => {
+                try {
+                    // Get the session for this response node
+                    const session = this.chatService.getActiveSession();
+                    if (!session) {
+                        this.messageService.error(core_1.nls.localize('theia/ai/chat-ui/sessionNotFoundForRetry', 'Session not found for retry'));
+                        return;
+                    }
+                    // Find the request associated with this response
+                    const request = session.model.getRequests().find(req => req.response.id === node.response.id);
+                    if (!request) {
+                        this.messageService.error(core_1.nls.localize('theia/ai/chat-ui/requestNotFoundForRetry', 'Request not found for retry'));
+                        return;
+                    }
+                    // Send the same request again using the chat service
+                    await this.chatService.sendRequest(node.sessionId, request.request);
+                }
+                catch (error) {
+                    console.error('Failed to retry chat message:', error);
+                    this.messageService.error(core_1.nls.localize('theia/ai/chat-ui/failedToRetry', 'Failed to retry message'));
+                }
+            }
+        });
+    }
+    registerToolbarItems(registry) {
+        registry.registerItem({
+            id: chat_view_commands_1.AI_CHAT_NEW_CHAT_WINDOW_COMMAND.id,
+            command: chat_view_commands_1.AI_CHAT_NEW_CHAT_WINDOW_COMMAND.id,
+            tooltip: chat_view_commands_1.AI_CHAT_NEW_CHAT_WINDOW_COMMAND.label,
+            isVisible: widget => this.activationService.isActive && this.withWidget(widget),
+            when: browser_1.ENABLE_AI_CONTEXT_KEY
+        });
+        registry.registerItem({
+            id: chat_view_commands_1.AI_CHAT_SHOW_CHATS_COMMAND.id,
+            command: chat_view_commands_1.AI_CHAT_SHOW_CHATS_COMMAND.id,
+            tooltip: chat_view_commands_1.AI_CHAT_SHOW_CHATS_COMMAND.label,
+            isVisible: widget => this.activationService.isActive && this.withWidget(widget),
+            when: browser_1.ENABLE_AI_CONTEXT_KEY
+        });
+        registry.registerItem({
+            id: 'chat-view.' + browser_1.AI_SHOW_SETTINGS_COMMAND.id,
+            command: browser_1.AI_SHOW_SETTINGS_COMMAND.id,
+            group: 'ai-settings',
+            priority: 3,
+            tooltip: core_1.nls.localize('theia/ai-chat-ui/open-settings-tooltip', 'Open AI settings...'),
+            isVisible: widget => this.activationService.isActive && this.withWidget(widget),
+            when: browser_1.ENABLE_AI_CONTEXT_KEY
+        });
+        const sessionSummarizibilityChangedEmitter = new core_1.Emitter();
+        this.taskContextService.onDidChange(() => sessionSummarizibilityChangedEmitter.fire());
+        this.chatService.onSessionEvent(event => event.type === 'activeChange' && sessionSummarizibilityChangedEmitter.fire());
+        this.activationService.onDidChangeActiveStatus(() => sessionSummarizibilityChangedEmitter.fire());
+        registry.registerItem({
+            id: 'chat-view.' + chat_view_commands_1.ChatCommands.AI_CHAT_SUMMARIZE_CURRENT_SESSION.id,
+            command: chat_view_commands_1.ChatCommands.AI_CHAT_SUMMARIZE_CURRENT_SESSION.id,
+            onDidChange: sessionSummarizibilityChangedEmitter.event,
+            when: browser_1.ENABLE_AI_CONTEXT_KEY
+        });
+        registry.registerItem({
+            id: 'chat-view.' + chat_view_commands_1.ChatCommands.AI_CHAT_OPEN_SUMMARY_FOR_CURRENT_SESSION.id,
+            command: chat_view_commands_1.ChatCommands.AI_CHAT_OPEN_SUMMARY_FOR_CURRENT_SESSION.id,
+            onDidChange: sessionSummarizibilityChangedEmitter.event,
+            when: browser_1.ENABLE_AI_CONTEXT_KEY
+        });
+    }
+    async selectChat(sessionId) {
+        let activeSessionId = sessionId;
+        if (!activeSessionId) {
+            const item = await this.askForChatSession();
+            if (item === undefined) {
+                return;
+            }
+            activeSessionId = item.id;
+        }
+        this.chatService.setActiveSession(activeSessionId, { focus: true });
+    }
+    async askForChatSession() {
+        const getItems = async () => {
+            const activeSessions = this.chatService.getSessions()
+                .filter(session => session.title)
+                .map(session => ({
+                session,
+                isActive: true,
+                lastDate: session.lastInteraction ? session.lastInteraction.getTime() : 0
+            }));
+            // Try to load persisted sessions, but don't fail if it doesn't work
+            let persistedSessions = [];
+            try {
+                const persistedIndex = await this.chatService.getPersistedSessions();
+                const activeIds = new Set(activeSessions.map(s => s.session.id));
+                persistedSessions = Object.values(persistedIndex)
+                    .filter(metadata => !activeIds.has(metadata.sessionId))
+                    .map(metadata => ({
+                    metadata,
+                    isActive: false,
+                    lastDate: metadata.saveDate
+                }));
+            }
+            catch (error) {
+                this.logger.error('Failed to load persisted sessions, showing only active sessions', error);
+                // Continue with just active sessions
+            }
+            // Combine and sort by last interaction/message date
+            const allSessions = [
+                ...activeSessions.map(s => {
+                    var _a;
+                    return ({
+                        isActive: true,
+                        id: s.session.id,
+                        title: s.session.title,
+                        lastDate: s.lastDate,
+                        firstRequestText: (_a = s.session.model.getRequests().at(0)) === null || _a === void 0 ? void 0 : _a.request.text
+                    });
+                }),
+                ...persistedSessions.map(s => ({
+                    isActive: false,
+                    id: s.metadata.sessionId,
+                    title: s.metadata.title,
+                    lastDate: s.lastDate,
+                    firstRequestText: undefined
+                }))
+            ].sort((a, b) => b.lastDate - a.lastDate);
+            return allSessions.map(session => {
+                // Add icon for persisted sessions to visually distinguish them
+                const icon = session.isActive ? '' : '$(archive) ';
+                const label = `${icon}${session.title}`;
+                return ({
+                    label,
+                    description: (0, date_fns_1.formatDistance)(new Date(session.lastDate), new Date(), { addSuffix: false, locale: getDateFnsLocale() }),
+                    detail: session.firstRequestText || (session.isActive ? undefined : core_1.nls.localize('theia/ai/chat-ui/persistedSession', 'Persisted session (click to restore)')),
+                    id: session.id,
+                    buttons: [AIChatContribution_1.RENAME_CHAT_BUTTON, AIChatContribution_1.REMOVE_CHAT_BUTTON]
+                });
+            });
+        };
+        const defer = new promise_util_1.Deferred();
+        const quickPick = this.quickInputService.createQuickPick();
+        quickPick.placeholder = core_1.nls.localize('theia/ai/chat-ui/selectChat', 'Select chat');
+        quickPick.canSelectMany = false;
+        quickPick.busy = true;
+        quickPick.show();
+        // Load items asynchronously
+        getItems().then(items => {
+            quickPick.items = items;
+            quickPick.busy = false;
+        }).catch(error => {
+            this.logger.error('Failed to load chat sessions', error);
+            quickPick.busy = false;
+            quickPick.placeholder = core_1.nls.localize('theia/ai/chat-ui/failedToLoadChats', 'Failed to load chat sessions');
+        });
+        quickPick.onDidTriggerItemButton(async (context) => {
+            if (context.button === AIChatContribution_1.RENAME_CHAT_BUTTON) {
+                quickPick.hide();
+                this.quickInputService.input({
+                    placeHolder: core_1.nls.localize('theia/ai/chat-ui/enterChatName', 'Enter chat name')
+                }).then(name => {
+                    if (name && name.length > 0) {
+                        const session = this.chatService.getSession(context.item.id);
+                        if (session) {
+                            session.title = name;
+                        }
+                    }
+                });
+            }
+            else if (context.button === AIChatContribution_1.REMOVE_CHAT_BUTTON) {
+                // Wait for deletion to complete before refreshing the list
+                this.chatService.deleteSession(context.item.id).then(() => getItems()).then(items => {
+                    quickPick.items = items;
+                    if (items.length === 0) {
+                        quickPick.hide();
+                    }
+                    // Update persisted sessions flag after deletion
+                    this.checkPersistedSessions();
+                }).catch(error => {
+                    this.logger.error('Failed to delete chat session', error);
+                    this.messageService.error(core_1.nls.localize('theia/ai/chat-ui/failedToDeleteSession', 'Failed to delete chat session'));
+                });
+            }
+        });
+        quickPick.onDidAccept(async () => {
+            const selectedItem = quickPick.selectedItems[0];
+            if (selectedItem) {
+                // Restore session if not already loaded
+                const session = this.chatService.getSession(selectedItem.id);
+                if (!session) {
+                    try {
+                        await this.chatService.getOrRestoreSession(selectedItem.id);
+                        // Update persisted sessions flag after restoration
+                        this.checkPersistedSessions();
+                    }
+                    catch (error) {
+                        this.logger.error('Failed to restore chat session', error);
+                        this.messageService.error(core_1.nls.localize('theia/ai/chat-ui/failedToRestoreSession', 'Failed to restore chat session'));
+                        defer.resolve(undefined);
+                        quickPick.hide();
+                        return;
+                    }
+                }
+            }
+            defer.resolve(selectedItem);
+            quickPick.hide();
+        });
+        quickPick.onDidHide(() => defer.resolve(undefined));
+        return defer.promise;
+    }
+    withWidget(widget = this.tryGetWidget(), predicate = () => true) {
+        return widget instanceof chat_view_widget_1.ChatViewWidget ? predicate(widget) : false;
+    }
+    extractChatView(chatView) {
+        this.secondaryWindowHandler.moveWidgetToSecondaryWindow(chatView);
+    }
+    canExtractChatView(chatView) {
+        return !chatView.secondaryWindow;
+    }
+    async summarizeActiveSession() {
+        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(core_1.nls.localize('theia/ai/chat-ui/unableToSummarizeCurrentSession', 'Unable to summarize current session. Please confirm that the summary agent is not disabled.'));
+            return undefined;
+        });
+    }
+    /**
+     * Prompts the user to select a chat agent
+     * @returns The selected agent or undefined if cancelled
+     */
+    /**
+     * Prompts the user to select a chat agent with an optional default (pre-selected) agent.
+     * @param defaultAgentId The id of the agent to pre-select, if present
+     * @returns The selected agent or undefined if cancelled
+     */
+    async selectAgent(defaultAgentId) {
+        const agents = this.chatAgentService.getAgents();
+        if (agents.length === 0) {
+            this.messageService.warn(core_1.nls.localize('theia/ai/chat-ui/noChatAgentsAvailable', 'No chat agents available.'));
+            return undefined;
+        }
+        const items = agents.map(agent => ({
+            label: agent.name || agent.id,
+            description: agent.description,
+            id: agent.id
+        }));
+        let preselected = undefined;
+        if (defaultAgentId) {
+            preselected = items.find(item => item.id === defaultAgentId);
+        }
+        const selected = await this.quickInputService.showQuickPick(items, {
+            placeholder: core_1.nls.localize('theia/ai/chat-ui/selectAgentQuickPickPlaceholder', 'Select an agent for the new session'),
+            activeItem: preselected
+        });
+        if (!selected) {
+            return undefined;
+        }
+        return this.chatAgentService.getAgent(selected.id);
+    }
+    /**
+     * Prompts the user to select a task context with special marking for currently opened files
+     * @returns The selected task context ID or undefined if cancelled
+     */
+    async selectTaskContextWithMarking() {
+        const contexts = this.taskContextService.getAll();
+        const openedFilesInfo = this.getOpenedTaskContextFiles();
+        // Create items with opened files marked and prioritized
+        const items = contexts.map(summary => {
+            const isOpened = openedFilesInfo.openedIds.includes(summary.id);
+            const isActive = openedFilesInfo.activeId === summary.id;
+            return {
+                label: isOpened ? `📄 ${summary.label} (${core_1.nls.localize('theia/ai/chat-ui/selectTaskContextQuickPickItem/currentlyOpen', 'currently open')})` : summary.label,
+                description: summary.id,
+                id: summary.id,
+                // We'll sort active file first, then opened files, then others
+                sortText: isActive ? `0-${summary.label}` : isOpened ? `1-${summary.label}` : `2-${summary.label}`
+            };
+        }).sort((a, b) => a.sortText.localeCompare(b.sortText));
+        const selected = await this.quickInputService.showQuickPick(items, {
+            placeholder: core_1.nls.localize('theia/ai/chat-ui/selectTaskContextQuickPickPlaceholder', 'Select a task context to attach')
+        });
+        return selected === null || selected === void 0 ? void 0 : selected.id;
+    }
+    /**
+     * Returns information about task context files that are currently opened
+     * @returns Object with arrays of opened context IDs and the active context ID
+     */
+    getOpenedTaskContextFiles() {
+        var _a;
+        // Get all contexts with their URIs
+        const allContexts = this.taskContextService.getAll();
+        const contextMap = new Map(); // Map of URI -> ID
+        // Create a map of URI string -> context ID for lookup
+        for (const context of allContexts) {
+            if (context.uri) {
+                contextMap.set(context.uri.toString(), context.id);
+            }
+        }
+        // Get all open editor URIs
+        const openEditorUris = this.editorManager.all.map(widget => widget.editor.uri.toString());
+        // Get the currently active/focused editor URI if any
+        const activeEditorUri = (_a = this.editorManager.currentEditor) === null || _a === void 0 ? void 0 : _a.editor.uri.toString();
+        let activeContextId;
+        if (activeEditorUri) {
+            activeContextId = contextMap.get(activeEditorUri);
+        }
+        // Filter to only task context files that are currently opened
+        const openedContextIds = [];
+        for (const uri of openEditorUris) {
+            const contextId = contextMap.get(uri);
+            if (contextId) {
+                openedContextIds.push(contextId);
+            }
+        }
+        return { openedIds: openedContextIds, activeId: activeContextId };
+    }
+};
+exports.AIChatContribution = AIChatContribution;
+AIChatContribution.RENAME_CHAT_BUTTON = {
+    iconClass: 'codicon-edit',
+    tooltip: core_1.nls.localize('theia/ai/chat-ui/renameChat', 'Rename Chat'),
+};
+AIChatContribution.REMOVE_CHAT_BUTTON = {
+    iconClass: 'codicon-remove-close',
+    tooltip: core_1.nls.localize('theia/ai/chat-ui/removeChat', 'Remove Chat'),
+};
+tslib_1.__decorate([
+    (0, inversify_1.inject)(ai_chat_1.ChatService),
+    tslib_1.__metadata("design:type", Object)
+], AIChatContribution.prototype, "chatService", void 0);
+tslib_1.__decorate([
+    (0, inversify_1.inject)(core_1.QuickInputService),
+    tslib_1.__metadata("design:type", Object)
+], AIChatContribution.prototype, "quickInputService", void 0);
+tslib_1.__decorate([
+    (0, inversify_1.inject)(task_context_service_1.TaskContextService),
+    tslib_1.__metadata("design:type", task_context_service_1.TaskContextService)
+], AIChatContribution.prototype, "taskContextService", void 0);
+tslib_1.__decorate([
+    (0, inversify_1.inject)(core_1.MessageService),
+    tslib_1.__metadata("design:type", core_1.MessageService)
+], AIChatContribution.prototype, "messageService", void 0);
+tslib_1.__decorate([
+    (0, inversify_1.inject)(chat_agent_service_1.ChatAgentService),
+    tslib_1.__metadata("design:type", Object)
+], AIChatContribution.prototype, "chatAgentService", void 0);
+tslib_1.__decorate([
+    (0, inversify_1.inject)(editor_manager_1.EditorManager),
+    tslib_1.__metadata("design:type", editor_manager_1.EditorManager)
+], AIChatContribution.prototype, "editorManager", void 0);
+tslib_1.__decorate([
+    (0, inversify_1.inject)(browser_1.AIActivationService),
+    tslib_1.__metadata("design:type", Object)
+], AIChatContribution.prototype, "activationService", void 0);
+tslib_1.__decorate([
+    (0, inversify_1.inject)(logger_1.ILogger),
+    (0, inversify_1.named)('AIChatContribution'),
+    tslib_1.__metadata("design:type", Object)
+], AIChatContribution.prototype, "logger", void 0);
+tslib_1.__decorate([
+    (0, inversify_1.inject)(secondary_window_handler_1.SecondaryWindowHandler),
+    tslib_1.__metadata("design:type", secondary_window_handler_1.SecondaryWindowHandler)
+], AIChatContribution.prototype, "secondaryWindowHandler", void 0);
+tslib_1.__decorate([
+    (0, inversify_1.postConstruct)(),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", []),
+    tslib_1.__metadata("design:returntype", void 0)
+], AIChatContribution.prototype, "initialize", null);
+exports.AIChatContribution = AIChatContribution = AIChatContribution_1 = tslib_1.__decorate([
+    (0, inversify_1.injectable)(),
+    tslib_1.__metadata("design:paramtypes", [])
+], AIChatContribution);
+function getDateFnsLocale() {
+    var _a;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return core_1.nls.locale ? (_a = locales[core_1.nls.locale]) !== null && _a !== void 0 ? _a : locales.enUS : locales.enUS;
+}
+//# sourceMappingURL=ai-chat-ui-contribution.js.map