@theia/ai-chat-ui 1.71.0-next.8 → 1.71.1

package/src/browser/chat-token-usage-indicator-util.spec.ts

@@ -0,0 +1,262 @@
+// *****************************************************************************
+// Copyright (C) 2026 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 { expect } from 'chai';
+import { Emitter, Event } from '@theia/core';
+import { ChatModel, ChatRequestModel, ResponseTokenUsage } from '@theia/ai-chat';
+import {
+    computeSessionTokenUsage,
+    decideTokenUsageWarning,
+    formatTokenCount,
+    getUsageColorClass,
+    isAboveTokenUsageWarningThreshold
+} from './chat-token-usage-indicator-util';
+
+const THRESHOLD = 100;
+const CONTEXT_WINDOW = 200;
+
+function createMockRequest(tokenUsage?: ResponseTokenUsage, isComplete = true): Partial<ChatRequestModel> {
+    return {
+        response: {
+            tokenUsage,
+            isComplete
+        } as ChatRequestModel['response']
+    };
+}
+
+function createMockChatModel(requests: Partial<ChatRequestModel>[]): ChatModel {
+    const emitter = new Emitter<unknown>();
+    return {
+        onDidChange: emitter.event as Event<unknown>,
+        id: 'test-model',
+        getRequests: () => requests as ChatRequestModel[],
+    } as ChatModel;
+}
+
+describe('ChatTokenUsageIndicator', () => {
+    describe('formatTokenCount', () => {
+        it('should return "-" for undefined', () => {
+            expect(formatTokenCount(undefined)).to.equal('-');
+        });
+
+        it('should return "-" for 0', () => {
+            expect(formatTokenCount(0)).to.equal('-');
+        });
+
+        it('should format numbers below 1000 as-is', () => {
+            expect(formatTokenCount(500)).to.equal('500');
+            expect(formatTokenCount(999)).to.equal('999');
+        });
+
+        it('should format numbers >= 1000 with k suffix and one decimal', () => {
+            expect(formatTokenCount(1000)).to.equal('1.0k');
+            expect(formatTokenCount(1500)).to.equal('1.5k');
+            expect(formatTokenCount(125000)).to.equal('125.0k');
+            expect(formatTokenCount(200000)).to.equal('200.0k');
+        });
+    });
+
+    describe('getUsageColorClass', () => {
+        it('returns none for 0 tokens regardless of threshold', () => {
+            expect(getUsageColorClass(0, THRESHOLD, CONTEXT_WINDOW)).to.equal('token-usage-none');
+        });
+
+        it('returns green for tokens below the threshold', () => {
+            expect(getUsageColorClass(1, THRESHOLD, CONTEXT_WINDOW)).to.equal('token-usage-green');
+            expect(getUsageColorClass(THRESHOLD - 1, THRESHOLD, CONTEXT_WINDOW)).to.equal('token-usage-green');
+        });
+
+        it('returns yellow for tokens at or above the threshold but below the context window size', () => {
+            expect(getUsageColorClass(THRESHOLD, THRESHOLD, CONTEXT_WINDOW)).to.equal('token-usage-yellow');
+            expect(getUsageColorClass(CONTEXT_WINDOW - 1, THRESHOLD, CONTEXT_WINDOW)).to.equal('token-usage-yellow');
+        });
+
+        it('returns red for tokens at or above the context window size', () => {
+            expect(getUsageColorClass(CONTEXT_WINDOW, THRESHOLD, CONTEXT_WINDOW)).to.equal('token-usage-red');
+            expect(getUsageColorClass(CONTEXT_WINDOW + 1, THRESHOLD, CONTEXT_WINDOW)).to.equal('token-usage-red');
+        });
+    });
+
+    describe('computeSessionTokenUsage', () => {
+        it('should return 0 when chatModel is undefined', () => {
+            expect(computeSessionTokenUsage(undefined)).to.equal(0);
+        });
+
+        it('should return 0 when there are no requests', () => {
+            const model = createMockChatModel([]);
+            expect(computeSessionTokenUsage(model)).to.equal(0);
+        });
+
+        it('should return 0 when requests have no token usage', () => {
+            const model = createMockChatModel([
+                createMockRequest(undefined),
+                createMockRequest(undefined)
+            ]);
+            expect(computeSessionTokenUsage(model)).to.equal(0);
+        });
+
+        it('should sum all tokens from a single request', () => {
+            const model = createMockChatModel([
+                createMockRequest({ inputTokens: 1000, outputTokens: 500 })
+            ]);
+            expect(computeSessionTokenUsage(model)).to.equal(1500);
+        });
+
+        it('should return only the last request tokens, not the sum', () => {
+            const model = createMockChatModel([
+                createMockRequest({ inputTokens: 1000, outputTokens: 500 }),
+                createMockRequest({ inputTokens: 2000, outputTokens: 800 })
+            ]);
+            // Only the last request: 2000+800 = 2800
+            expect(computeSessionTokenUsage(model)).to.equal(2800);
+        });
+
+        it('should return last request tokens from 3 requests (2 complete, 1 in-progress)', () => {
+            const model = createMockChatModel([
+                createMockRequest({ inputTokens: 1000, outputTokens: 500 }, true),
+                createMockRequest({ inputTokens: 2000, outputTokens: 800 }, true),
+                createMockRequest({ inputTokens: 3000, outputTokens: 200 }, false) // in-progress
+            ]);
+            // Only the last request: 3000+200 = 3200
+            expect(computeSessionTokenUsage(model)).to.equal(3200);
+        });
+
+        it('should skip requests without token usage and return last with usage', () => {
+            const model = createMockChatModel([
+                createMockRequest({ inputTokens: 1000, outputTokens: 500 }),
+                createMockRequest(undefined),
+                createMockRequest({ inputTokens: 3000, outputTokens: 1000 })
+            ]);
+            // Last request with usage: 3000+1000 = 4000
+            expect(computeSessionTokenUsage(model)).to.equal(4000);
+        });
+
+        it('should include cache creation and cache read tokens in the total', () => {
+            const model = createMockChatModel([
+                createMockRequest({
+                    inputTokens: 1000,
+                    outputTokens: 500,
+                    cacheCreationInputTokens: 200,
+                    cacheReadInputTokens: 300
+                })
+            ]);
+            // 1000+500+200+300 = 2000
+            expect(computeSessionTokenUsage(model)).to.equal(2000);
+        });
+
+        it('should return only last request cache tokens, not sum across requests', () => {
+            const model = createMockChatModel([
+                createMockRequest({
+                    inputTokens: 1000,
+                    outputTokens: 500,
+                    cacheCreationInputTokens: 200,
+                    cacheReadInputTokens: 300
+                }),
+                createMockRequest({
+                    inputTokens: 500,
+                    outputTokens: 100,
+                    cacheCreationInputTokens: 50,
+                    cacheReadInputTokens: 50
+                })
+            ]);
+            // Only last request: 500+100+50+50 = 700
+            expect(computeSessionTokenUsage(model)).to.equal(700);
+        });
+
+        it('should return in-progress request token usage when it is last', () => {
+            const model = createMockChatModel([
+                createMockRequest({ inputTokens: 1000, outputTokens: 500 }, true),
+                createMockRequest({ inputTokens: 5000, outputTokens: 200 }, false) // in-progress
+            ]);
+            // Only last request: 5000+200 = 5200
+            expect(computeSessionTokenUsage(model)).to.equal(5200);
+        });
+
+        it('should return total from in-progress request when it is the only request', () => {
+            const model = createMockChatModel([
+                createMockRequest({ inputTokens: 5000, outputTokens: 200 }, false)
+            ]);
+            expect(computeSessionTokenUsage(model)).to.equal(5200);
+        });
+
+        it('should skip trailing requests without usage and find last with usage', () => {
+            const model = createMockChatModel([
+                createMockRequest({ inputTokens: 1000, outputTokens: 500 }),
+                createMockRequest({ inputTokens: 3000, outputTokens: 1000 }),
+                createMockRequest(undefined)
+            ]);
+            // Last request with usage: 3000+1000 = 4000
+            expect(computeSessionTokenUsage(model)).to.equal(4000);
+        });
+    });
+
+    describe('isAboveTokenUsageWarningThreshold', () => {
+        it('is false for 0 tokens', () => {
+            expect(isAboveTokenUsageWarningThreshold(0, THRESHOLD)).to.equal(false);
+        });
+
+        it('is false for tokens below the threshold', () => {
+            expect(isAboveTokenUsageWarningThreshold(THRESHOLD - 1, THRESHOLD)).to.equal(false);
+        });
+
+        it('is true for tokens at the threshold', () => {
+            expect(isAboveTokenUsageWarningThreshold(THRESHOLD, THRESHOLD)).to.equal(true);
+        });
+
+        it('is true for tokens above the threshold', () => {
+            expect(isAboveTokenUsageWarningThreshold(THRESHOLD + 1, THRESHOLD)).to.equal(true);
+        });
+    });
+
+    describe('decideTokenUsageWarning', () => {
+        it('resets when usage is below the threshold', () => {
+            expect(decideTokenUsageWarning({
+                totalTokens: 50,
+                threshold: THRESHOLD,
+                alreadyNotified: true
+            })).to.equal('reset');
+        });
+
+        it('resets when usage is zero', () => {
+            expect(decideTokenUsageWarning({
+                totalTokens: 0,
+                threshold: THRESHOLD,
+                alreadyNotified: true
+            })).to.equal('reset');
+        });
+
+        it('skips when the session has already been notified', () => {
+            expect(decideTokenUsageWarning({
+                totalTokens: THRESHOLD + 50,
+                threshold: THRESHOLD,
+                alreadyNotified: true
+            })).to.equal('skip');
+        });
+
+        it('notifies when usage crosses the threshold and the session has not been notified yet', () => {
+            expect(decideTokenUsageWarning({
+                totalTokens: THRESHOLD,
+                threshold: THRESHOLD,
+                alreadyNotified: false
+            })).to.equal('notify');
+            expect(decideTokenUsageWarning({
+                totalTokens: THRESHOLD * 2,
+                threshold: THRESHOLD,
+                alreadyNotified: false
+            })).to.equal('notify');
+        });
+    });
+});

package/src/browser/chat-token-usage-indicator-util.ts

@@ -0,0 +1,151 @@
+// *****************************************************************************
+// Copyright (C) 2026 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 { ChatModel, ResponseTokenUsage } from '@theia/ai-chat';
+import { nls } from '@theia/core/lib/common/nls';
+import { MarkdownString } from '@theia/core/lib/common/markdown-rendering';
+
+/**
+ * Provisional context window size used as the denominator for the indicator bar
+ * fill and the tooltip's "Total: X / Y" display until per-model context sizes
+ * are available. See issue #17323 comments for context.
+ */
+export const CHAT_CONTEXT_WINDOW_SIZE = 200000;
+
+export type TokenUsageWarningDecision = 'notify' | 'reset' | 'skip';
+
+/** Returns true when the given total has crossed (>=) the configured warning threshold. */
+export function isAboveTokenUsageWarningThreshold(totalTokens: number, threshold: number): boolean {
+    return totalTokens > 0 && totalTokens >= threshold;
+}
+
+/**
+ * Pure decision function for whether to show the token usage warning for a session.
+ * Callers are expected to short-circuit before invoking this when the warning feature
+ * is disabled, so this helper is not concerned with the enabled state.
+ * - `reset`: usage is below the threshold; any prior "already notified" state for this session should be cleared.
+ * - `skip`:  we already notified for this session while still above the threshold.
+ * - `notify`: warning should be shown now and the session marked as notified.
+ */
+export function decideTokenUsageWarning(args: {
+    totalTokens: number;
+    threshold: number;
+    alreadyNotified: boolean;
+}): TokenUsageWarningDecision {
+    if (!isAboveTokenUsageWarningThreshold(args.totalTokens, args.threshold)) {
+        return 'reset';
+    }
+    if (args.alreadyNotified) {
+        return 'skip';
+    }
+    return 'notify';
+}
+
+export function formatTokenCount(count: number | undefined): string {
+    if (count === undefined || count === 0) {
+        return '-';
+    }
+    if (count >= 1000) {
+        return `${(count / 1000).toFixed(1)}k`;
+    }
+    return count.toString();
+}
+
+/**
+ * Returns the CSS class for the token usage indicator based on the current
+ * total, the configured warning threshold, and the assumed context window size.
+ * Yellow band: [threshold, contextWindowSize). Red band: [contextWindowSize, ∞).
+ */
+export function getUsageColorClass(totalTokens: number, threshold: number, contextWindowSize: number = CHAT_CONTEXT_WINDOW_SIZE): string {
+    if (totalTokens === 0) {
+        return 'token-usage-none';
+    }
+    if (totalTokens < threshold) {
+        return 'token-usage-green';
+    }
+    if (totalTokens < contextWindowSize) {
+        return 'token-usage-yellow';
+    }
+    return 'token-usage-red';
+}
+
+export function computeSessionTokenUsage(chatModel?: ChatModel): number {
+    if (!chatModel) {
+        return 0;
+    }
+    const requests = chatModel.getRequests();
+    for (let i = requests.length - 1; i >= 0; i--) {
+        const usage: ResponseTokenUsage | undefined = requests[i].response.tokenUsage;
+        if (usage) {
+            return usage.inputTokens
+                + usage.outputTokens
+                + (usage.cacheCreationInputTokens ?? 0)
+                + (usage.cacheReadInputTokens ?? 0);
+        }
+    }
+    return 0;
+}
+
+export function getLatestTokenUsage(chatModel?: ChatModel): ResponseTokenUsage | undefined {
+    if (!chatModel) {
+        return undefined;
+    }
+    const requests = chatModel.getRequests();
+    for (let i = requests.length - 1; i >= 0; i--) {
+        const usage = requests[i].response.tokenUsage;
+        if (usage) {
+            return usage;
+        }
+    }
+    return undefined;
+}
+
+export function buildBarTooltip(usage: ResponseTokenUsage | undefined, totalTokens: number, threshold: number): MarkdownString | undefined {
+    if (!usage) {
+        return undefined;
+    }
+    const lines: string[] = [
+        `**${nls.localize('theia/ai/chat-ui/tokenUsageLabel', 'Token Usage')}**`
+    ];
+    const colorClass = getUsageColorClass(totalTokens, threshold);
+    if (colorClass === 'token-usage-yellow') {
+        lines.push(`⚠ ${nls.localize('theia/ai/chat-ui/tokenUsageWarning', 'Token usage warning threshold reached.')}`, '');
+    } else if (colorClass === 'token-usage-red') {
+        lines.push(`⚠ ${nls.localize('theia/ai/chat-ui/tokenUsageOverflow', 'Token usage well past the warning threshold. Consider compacting or starting a new session.')}`, '');
+    }
+    lines.push(`${nls.localizeByDefault('Input: {0}',
+        formatTokenCount(usage.inputTokens))} | ${nls.localizeByDefault('Output: {0}',
+            formatTokenCount(usage.outputTokens))}`);
+    const cacheParts: string[] = [];
+    if (usage.cacheReadInputTokens) {
+        cacheParts.push(nls.localize('theia/ai/chat-ui/tokenUsageTooltipCacheRead', 'Cache read: {0}', formatTokenCount(usage.cacheReadInputTokens)));
+    }
+    if (usage.cacheCreationInputTokens) {
+        cacheParts.push(nls.localize('theia/ai/chat-ui/tokenUsageTooltipCacheCreate', 'Cache creation: {0}', formatTokenCount(usage.cacheCreationInputTokens)));
+    }
+    if (cacheParts.length > 0) {
+        lines.push(cacheParts.join(' | '));
+    }
+    const percentage = Math.round((totalTokens / CHAT_CONTEXT_WINDOW_SIZE) * 100);
+    lines.push(nls.localize(
+        'theia/ai/chat-ui/tokenUsageTooltipTotal',
+        'Total: {0} / {1} ({2}%)',
+        formatTokenCount(totalTokens),
+        formatTokenCount(CHAT_CONTEXT_WINDOW_SIZE),
+        percentage
+    ));
+    return { value: lines.join('  \n') };
+}

package/src/browser/chat-tree-view/chat-view-tree-input-widget.tsx

@@ -19,7 +19,7 @@ import { AIChatInputWidget, type AIChatInputConfiguration } from '../chat-input-
 import type { EditableRequestNode } from './chat-view-tree-widget';
 import { URI } from '@theia/core';
 import { CHAT_VIEW_LANGUAGE_EXTENSION } from '../chat-view-language-contribution';
-import type { ChatRequestModel, EditableChatRequestModel, ChatHierarchyBranch } from '@theia/ai-chat';
+import type { ChatModel, ChatRequestModel, EditableChatRequestModel, ChatHierarchyBranch } from '@theia/ai-chat';
 import type { AIVariableResolutionRequest } from '@theia/ai-core';
 import { Key } from '@theia/core/lib/browser';
 
@@ -120,4 +120,12 @@ export class AIChatTreeInputWidget extends AIChatInputWidget {
     protected override deleteContextElement(index: number): void {
         this.request.editContextManager.deleteVariables(index);
     }
+
+    /**
+     * No-op in edit mode: the token usage warning is owned by the main chat input
+     * widget so we avoid double-notifying when an edit widget is open alongside it.
+     */
+    protected override evaluateTokenUsageWarning(_chatModel: ChatModel): void {
+        // Intentionally empty.
+    }
 }

package/src/browser/chat-tree-view/chat-view-tree-widget.tsx

@@ -57,8 +57,10 @@ import {
 } from '@theia/core/shared/inversify';
 import * as React from '@theia/core/shared/react';
 import { ImageContextVariable } from '@theia/ai-chat/lib/common/image-context-variable';
+import { MarkdownStringImpl } from '@theia/core/lib/common/markdown-rendering';
 import { ChatNodeToolbarActionContribution } from '../chat-node-toolbar-action-contribution';
 import { ChatResponsePartRenderer } from '../chat-response-part-renderer';
+import { formatTokenCount } from '../chat-token-usage-indicator-util';
 import { useMarkdownRendering } from '../chat-response-renderer/markdown-part-renderer';
 import { ProgressMessage } from '../chat-progress-message';
 import { AIChatTreeInputFactory, type AIChatTreeInputWidget } from './chat-view-tree-input-widget';
@@ -219,7 +221,7 @@ export class ChatViewTreeWidget extends TreeWidget {
 
         this.toDispose.pushAll([
             this.toDisposeOnChatModelChange,
-            this.activationService.onDidChangeActiveStatus(change => {
+            this.activationService.onDidChangeCanRun(change => {
                 this.chatInputs.forEach(widget => {
                     widget.setEnabled(change);
                 });
@@ -599,9 +601,26 @@ export class ChatViewTreeWidget extends TreeWidget {
                 <h3 ref={agentLabel}
                     className='theia-AgentLabel'
                     onMouseEnter={() => {
-                        if (agentDescription) {
+                        const tokenUsage = isResponseNode(node) ? node.response.tokenUsage : undefined;
+                        const hasTokenInfo = tokenUsage && (tokenUsage.inputTokens > 0 || tokenUsage.outputTokens > 0);
+                        const tokenInfo = hasTokenInfo
+                            ? `${nls.localize('theia/ai/chat-ui/tokenUsageLabel', 'Token Usage')}: ${nls.localizeByDefault(
+                                'Input: {0}', formatTokenCount(tokenUsage.inputTokens))} | ${nls.localizeByDefault(
+                                'Output: {0}', formatTokenCount(tokenUsage.outputTokens))}`
+                            : undefined;
+                        if (agentDescription || tokenInfo) {
+                            const md = new MarkdownStringImpl();
+                            if (agentDescription) {
+                                md.appendMarkdown(agentDescription);
+                            }
+                            if (agentDescription && tokenInfo) {
+                                md.appendMarkdown('\n\n---\n\n');
+                            }
+                            if (tokenInfo) {
+                                md.appendMarkdown(tokenInfo);
+                            }
                             this.hoverService.requestHover({
-                                content: agentDescription,
+                                content: md,
                                 target: agentLabel.current!,
                                 position: 'right'
                             });

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

@@ -0,0 +1,87 @@
+// *****************************************************************************
+// Copyright (C) 2026 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 { createPreferenceProxy, PreferenceContribution, PreferenceProxy, PreferenceSchema, PreferenceService } from '@theia/core/lib/common/preferences';
+import { nls } from '@theia/core/lib/common/nls';
+import { interfaces } from '@theia/core/shared/inversify';
+
+export const CHAT_VIEW_TOKEN_USAGE_ENABLED = 'ai-features.chat.tokenUsageIndicator.enabled';
+export const CHAT_VIEW_TOKEN_USAGE_WARNING_ENABLED = 'ai-features.chat.tokenUsageWarning.enabled';
+export const CHAT_VIEW_TOKEN_USAGE_WARNING_THRESHOLD_PERCENTAGE = 'ai-features.chat.tokenUsageWarning.defaultThresholdPercentage';
+
+export const CHAT_VIEW_TOKEN_USAGE_WARNING_THRESHOLD_PERCENTAGE_DEFAULT = 80;
+
+export const chatViewPreferenceSchema: PreferenceSchema = {
+    properties: {
+        [CHAT_VIEW_TOKEN_USAGE_ENABLED]: {
+            type: 'boolean',
+            default: false,
+            description: nls.localize(
+                'theia/ai/chat-ui/tokenUsageIndicatorEnabled',
+                'Controls whether the experimental token usage indicator is shown in the chat view. ' +
+                'This feature is experimental and token counts may be inaccurate depending on the model and provider.'
+            ),
+            tags: ['experimental']
+        },
+        [CHAT_VIEW_TOKEN_USAGE_WARNING_ENABLED]: {
+            type: 'boolean',
+            default: false,
+            description: nls.localize(
+                'theia/ai/chat-ui/tokenUsageWarningEnabled',
+                'Controls whether a notification is shown when a chat session\'s token usage crosses the configured threshold. ' +
+                'Requires the language model provider to report token usage.'
+            ),
+            tags: ['experimental']
+        },
+        [CHAT_VIEW_TOKEN_USAGE_WARNING_THRESHOLD_PERCENTAGE]: {
+            type: 'number',
+            minimum: 1,
+            maximum: 100,
+            default: CHAT_VIEW_TOKEN_USAGE_WARNING_THRESHOLD_PERCENTAGE_DEFAULT,
+            description: nls.localize(
+                'theia/ai/chat-ui/tokenUsageWarningThresholdPercentage',
+                'Percentage of the model\'s context window at which the token usage warning is triggered. ' +
+                'This value also drives the warning/error color bands of the token usage indicator. ' +
+                'Currently resolves against an assumed 200k context window; will use the real per-model context size once available.'
+            ),
+            tags: ['experimental']
+        }
+    }
+};
+
+export interface ChatViewConfiguration {
+    [CHAT_VIEW_TOKEN_USAGE_ENABLED]: boolean;
+    [CHAT_VIEW_TOKEN_USAGE_WARNING_ENABLED]: boolean;
+    [CHAT_VIEW_TOKEN_USAGE_WARNING_THRESHOLD_PERCENTAGE]: number;
+}
+
+export const ChatViewPreferenceContribution = Symbol('ChatViewPreferenceContribution');
+export const ChatViewPreferences = Symbol('ChatViewPreferences');
+export type ChatViewPreferences = PreferenceProxy<ChatViewConfiguration>;
+
+export function createChatViewPreferences(preferences: PreferenceService, schema: PreferenceSchema = chatViewPreferenceSchema): ChatViewPreferences {
+    return createPreferenceProxy(preferences, schema);
+}
+
+export function bindChatViewPreferences(bind: interfaces.Bind): void {
+    bind(ChatViewPreferences).toDynamicValue(ctx => {
+        const preferences = ctx.container.get<PreferenceService>(PreferenceService);
+        const contribution = ctx.container.get<PreferenceContribution>(ChatViewPreferenceContribution);
+        return createChatViewPreferences(preferences, contribution.schema);
+    }).inSingletonScope();
+    bind(ChatViewPreferenceContribution).toConstantValue({ schema: chatViewPreferenceSchema });
+    bind(PreferenceContribution).toService(ChatViewPreferenceContribution);
+}

package/src/browser/chat-view-widget-toolbar-contribution.tsx

@@ -57,7 +57,7 @@ export class ChatViewWidgetToolbarContribution implements TabBarToolbarContribut
 
         this.commandRegistry.registerCommand(ChatCommands.EDIT_SESSION_SETTINGS, {
             execute: () => this.openJsonDataDialog(),
-            isEnabled: widget => this.activationService.isActive && widget instanceof ChatViewWidget,
+            isEnabled: widget => this.activationService.canRun && widget instanceof ChatViewWidget,
             isVisible: widget => this.activationService.isActive && widget instanceof ChatViewWidget
         });
     }
@@ -82,8 +82,9 @@ export class ChatViewWidgetToolbarContribution implements TabBarToolbarContribut
         registry.registerItem({
             id: ChatCommands.EDIT_SESSION_SETTINGS.id,
             command: ChatCommands.EDIT_SESSION_SETTINGS.id,
-            tooltip: nls.localize('theia/ai/session-settings-dialog/tooltip', 'Set Session Settings'),
+            tooltip: nls.localize('theia/ai/session-settings-dialog/tooltip', 'Set Session Settings...'),
             priority: 3,
+            group: 'chat-settings',
             when: ENABLE_AI_CONTEXT_KEY
         });
     }

package/src/browser/chat-view-widget.tsx

@@ -13,7 +13,7 @@
 //
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
-import { CommandService, ContributionProvider, deepClone, Emitter, Event, MessageService, PreferenceService, URI } from '@theia/core';
+import { CommandService, ContributionProvider, deepClone, Emitter, Event, MessageService, URI } from '@theia/core';
 import { ChatRequest, ChatRequestModel, ChatService, ChatSession, ChatSessionSettings, isActiveSessionChangedEvent, MutableChatModel } from '@theia/ai-chat';
 import { GenericCapabilitySelections, AIVariableResolutionRequest } from '@theia/ai-core';
 import { BaseWidget, codicon, ExtractableWidget, Message, PanelLayout, StatefulWidget } from '@theia/core/lib/browser';
@@ -46,9 +46,6 @@ export class ChatViewWidget extends BaseWidget implements ExtractableWidget, Sta
     @inject(MessageService)
     protected messageService: MessageService;
 
-    @inject(PreferenceService)
-    protected readonly preferenceService: PreferenceService;
-
     @inject(CommandService)
     protected readonly commandService: CommandService;
 
@@ -127,7 +124,7 @@ export class ChatViewWidget extends BaseWidget implements ExtractableWidget, Sta
 
         this.updateInputEnabledState();
 
-        this.activationService.onDidChangeActiveStatus(change => {
+        this.activationService.onDidChangeCanRun(change => {
             this.treeWidget.setEnabled(change);
             this.updateInputEnabledState();
             this.update();
@@ -152,9 +149,9 @@ export class ChatViewWidget extends BaseWidget implements ExtractableWidget, Sta
     }
 
     protected async updateInputEnabledState(): Promise<void> {
-        const shouldEnable = this.activationService.isActive && await this.shouldEnableInput();
+        const shouldEnable = this.activationService.canRun && await this.shouldEnableInput();
         this.inputWidget.setEnabled(shouldEnable);
-        this.treeWidget.setEnabled(this.activationService.isActive);
+        this.treeWidget.setEnabled(this.activationService.canRun);
     }
 
     /**