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

package/lib/browser/chat-input-widget.js

@@ -21,6 +21,7 @@ const tslib_1 = require("tslib");
 const ai_chat_1 = require("@theia/ai-chat");
 const chat_agent_service_1 = require("@theia/ai-chat/lib/common/chat-agent-service");
 const ai_core_1 = require("@theia/ai-core");
+const frontend_language_model_service_1 = require("@theia/ai-core/lib/browser/frontend-language-model-service");
 const change_set_decorator_service_1 = require("@theia/ai-chat/lib/browser/change-set-decorator-service");
 const image_context_variable_1 = require("@theia/ai-chat/lib/common/image-context-variable");
 const browser_1 = require("@theia/ai-core/lib/browser");
@@ -49,11 +50,18 @@ const chat_capabilities_panel_1 = require("./chat-capabilities-panel");
 const chat_input_focus_service_1 = require("./chat-input-focus-service");
 const generic_capabilities_service_1 = require("./generic-capabilities-service");
 const generic_capabilities_section_1 = require("./generic-capabilities-section");
+const preferences_1 = require("@theia/core/lib/common/preferences");
+const chat_view_preferences_1 = require("./chat-view-preferences");
+const chat_token_usage_indicator_util_1 = require("./chat-token-usage-indicator-util");
+const chat_view_commands_1 = require("./chat-view-commands");
 exports.AIChatInputConfiguration = Symbol('AIChatInputConfiguration');
 let AIChatInputWidget = class AIChatInputWidget extends browser_2.ReactWidget {
     constructor() {
         super(...arguments);
         this.fileValidationState = new Map();
+        this.tokenUsageEnabled = false;
+        /** Sessions we have already notified for the current warning cycle (re-armed when usage drops below the threshold). */
+        this.notifiedSessions = new Set();
         this.editorRef = undefined;
         this.editorReady = new promise_util_1.Deferred();
         this.handleModeChange = async (mode) => {
@@ -62,6 +70,35 @@ let AIChatInputWidget = class AIChatInputWidget extends browser_2.ReactWidget {
                 await this.updateCapabilitiesForAgent(this.receivingAgent.agentId, mode);
             }
         };
+        this.handleReasoningChange = async (level) => {
+            const session = this.chatService.getSessions().find(s => s.model.id === this._chatModel?.id);
+            if (!session) {
+                return;
+            }
+            const currentSettings = session.model.settings ?? {};
+            const newSettings = {
+                ...currentSettings,
+                commonSettings: {
+                    ...currentSettings.commonSettings,
+                    reasoning: { level }
+                }
+            };
+            session.model.setSettings(newSettings);
+            // Auto-persist the reasoning selection per-agent so it is restored on the next session
+            // and the capabilities indicator does not light up for an unrelated configuration concern.
+            if (this.receivingAgent) {
+                try {
+                    await this.aiSettingsService.updateAgentSettings(this.receivingAgent.agentId, {
+                        reasoning: { level }
+                    });
+                    this.savedReasoning = { level };
+                }
+                catch (error) {
+                    console.error('Failed to persist reasoning selection:', error);
+                }
+            }
+            this.update();
+        };
         this.handleCapabilityChange = (fragmentId, enabled) => {
             const defaultCapability = this.capabilityDefaults.find(c => c.fragmentId === fragmentId);
             const sessionOverrides = new Map(this.userCapabilityOverrides);
@@ -182,6 +219,61 @@ let AIChatInputWidget = class AIChatInputWidget extends browser_2.ReactWidget {
         const nextModeId = this.receivingAgent.modes[nextIndex].id;
         this.handleModeChange(nextModeId);
     }
+    /**
+     * Resolves the reasoning level to display in the selector. Priority: session override →
+     * persisted per-agent selection (from {@link AISettingsService}) →
+     * `ai-features.reasoning.defaults` preference entry matching the current model/agent →
+     * model's declared default → `'off'`.
+     */
+    getCurrentReasoningLevel() {
+        if (!this.currentReasoningSupport) {
+            return undefined;
+        }
+        const session = this.chatService.getSessions().find(s => s.model.id === this._chatModel?.id);
+        const sessionLevel = session?.model.settings?.commonSettings?.reasoning?.level;
+        if (sessionLevel) {
+            return sessionLevel;
+        }
+        if (this.savedReasoning?.level) {
+            return this.savedReasoning.level;
+        }
+        return this.resolvePreferenceReasoningLevel() ?? this.currentReasoningSupport.defaultLevel ?? 'off';
+    }
+    resolvePreferenceReasoningLevel() {
+        if (!this.preferenceService || !this.currentLanguageModelId) {
+            return undefined;
+        }
+        const entries = this.preferenceService.get(ai_core_1.PREFERENCE_NAME_REASONING, []);
+        const [providerId, modelId] = this.currentLanguageModelId.split('/');
+        return (0, frontend_language_model_service_1.mergeReasoningSettings)(entries, modelId, providerId, this.receivingAgent?.agentId)?.reasoning?.level;
+    }
+    async updateReasoningSupport(agentId) {
+        let support;
+        let modelId;
+        if (agentId) {
+            const agent = this.chatAgentService.getAgent(agentId);
+            if (agent) {
+                for (const requirement of agent.languageModelRequirements ?? []) {
+                    try {
+                        const model = await this.languageModelRegistry.selectLanguageModel({ agent: agent.id, ...requirement });
+                        if (model?.reasoningSupport) {
+                            support = model.reasoningSupport;
+                            modelId = model.id;
+                            break;
+                        }
+                    }
+                    catch (error) {
+                        console.warn('Failed to resolve language model for reasoning support:', error);
+                    }
+                }
+            }
+        }
+        if (support !== this.currentReasoningSupport || modelId !== this.currentLanguageModelId) {
+            this.currentReasoningSupport = support;
+            this.currentLanguageModelId = modelId;
+            this.update();
+        }
+    }
     async updateCapabilitiesForAgent(agentId, modeId, preserveOverrides) {
         const capabilities = await this.capabilitiesService.getCapabilitiesForAgent(agentId, modeId);
         this.capabilityDefaults = capabilities;
@@ -190,19 +282,44 @@ let AIChatInputWidget = class AIChatInputWidget extends browser_2.ReactWidget {
             const agentSettings = await this.aiSettingsService.getAgentSettings(agentId);
             const savedOverrides = agentSettings?.capabilityOverrides;
             const savedGenericSelections = agentSettings?.genericCapabilitySelections;
+            const savedReasoning = agentSettings?.reasoning;
             // Store saved state for comparison
             this.savedCapabilityOverrides = savedOverrides ? { ...savedOverrides } : undefined;
             this.savedGenericCapabilitySelections = savedGenericSelections ? { ...savedGenericSelections } : undefined;
+            this.savedReasoning = savedReasoning ? { ...savedReasoning } : undefined;
             // Initialize from saved settings, or empty if none
             this.userCapabilityOverrides = savedOverrides
                 ? new Map(Object.entries(savedOverrides))
                 : new Map();
             this.genericCapabilitySelections = savedGenericSelections ?? {};
+            // Mirror the saved per-agent reasoning into the chat session so the selector reflects it
+            // immediately on session/agent switch.
+            this.applyReasoningToSession(savedReasoning);
         }
         // Update disabled generic capabilities (already used in agent prompt)
         this.disabledGenericCapabilities = await this.capabilitiesService.getUsedGenericCapabilitiesForAgent(agentId, modeId);
         this.update();
     }
+    /** Updates the active chat session's `commonSettings.reasoning`; pass `undefined` to clear. */
+    applyReasoningToSession(reasoning) {
+        const session = this.chatService.getSessions().find(s => s.model.id === this._chatModel?.id);
+        if (!session) {
+            return;
+        }
+        const currentSettings = session.model.settings ?? {};
+        const currentCommon = currentSettings.commonSettings ?? {};
+        if ((currentCommon.reasoning?.level ?? undefined) === (reasoning?.level ?? undefined)) {
+            return; // no-op when already in sync
+        }
+        const newCommon = { ...currentCommon };
+        if (reasoning) {
+            newCommon.reasoning = { ...reasoning };
+        }
+        else {
+            delete newCommon.reasoning;
+        }
+        session.model.setSettings({ ...currentSettings, commonSettings: newCommon });
+    }
     async updateAvailableGenericCapabilities() {
         if (!this.genericCapabilitiesService) {
             return;
@@ -234,6 +351,18 @@ let AIChatInputWidget = class AIChatInputWidget extends browser_2.ReactWidget {
         }
         return new Map(Object.entries(overrides));
     }
+    /**
+     * Extracts the mode ID from the last request in the chat model.
+     * Used to restore the user's selected mode when switching sessions or on reload.
+     */
+    getLastModeIdFromModel(chatModel) {
+        const requests = chatModel.getRequests();
+        if (requests.length === 0) {
+            return undefined;
+        }
+        const lastRequest = requests[requests.length - 1];
+        return lastRequest.request.modeId;
+    }
     /**
      * Extracts generic capability selections from the last request in the chat model.
      * Used to restore user's selections when switching sessions or on reload.
@@ -304,12 +433,18 @@ let AIChatInputWidget = class AIChatInputWidget extends browser_2.ReactWidget {
     }
     /**
      * Checks if there are any unsaved changes (capability overrides or generic selections).
+     * Reasoning is auto-persisted in {@link handleReasoningChange} and is intentionally excluded.
      */
     hasAnyChangesFromSaved() {
-        return (this.hasCapabilityChangesFromSaved() || this.hasGenericCapabilityChangesFromSaved()) && this.receivingAgent !== undefined;
+        if (this.receivingAgent === undefined) {
+            return false;
+        }
+        return this.hasCapabilityChangesFromSaved()
+            || this.hasGenericCapabilityChangesFromSaved();
     }
     /**
      * Saves current capability selections to settings.
+     * Reasoning is auto-persisted via {@link handleReasoningChange} and is not part of this flow.
      */
     async saveCurrentSelectionsToSettings() {
         if (!this.receivingAgent) {
@@ -388,6 +523,9 @@ let AIChatInputWidget = class AIChatInputWidget extends browser_2.ReactWidget {
         this.userCapabilityOverrides = this.getLastCapabilityOverridesFromModel(chatModel);
         this.genericCapabilitySelections = this.getLastGenericCapabilitySelectionsFromModel(chatModel);
         this.onDisposeForChatModel.push(chatModel.onDidChange(event => {
+            if (event.kind === 'responseChanged') {
+                this.evaluateTokenUsageWarning(chatModel);
+            }
             if (event.kind === 'addVariable') {
                 // Validate files added via any path (including LLM tool calls)
                 // Get the current variables and validate any new file variables
@@ -412,6 +550,16 @@ let AIChatInputWidget = class AIChatInputWidget extends browser_2.ReactWidget {
             }
         }));
         this._chatModel = chatModel;
+        // Evaluate the warning on attach. `notifiedSessions` lives on this widget
+        // instance, so the warning fires at most once per (widget lifetime × session):
+        // - Within the same widget, switching between sessions that have already been
+        //   notified does not re-notify.
+        // - Closing and reopening the chat view creates a fresh widget with an empty
+        //   Set, so sessions still above the threshold will be warned about again the
+        //   first time they are shown after reopen — once per session. Accepted as a
+        //   rare corner case; promoting the state to the ChatSession would avoid it
+        //   but isn't worth the coupling today.
+        this.evaluateTokenUsageWarning(chatModel);
         this.scheduleUpdateReceivingAgent();
         this.update();
     }
@@ -424,8 +572,8 @@ let AIChatInputWidget = class AIChatInputWidget extends browser_2.ReactWidget {
         this.id = AIChatInputWidget_1.ID;
         this.title.closable = false;
         this.toDispose.push(this.resources.add(this.getResourceUri(), ''));
-        this.toDispose.push(this.aiActivationService.onDidChangeActiveStatus(() => {
-            this.setEnabled(this.aiActivationService.isActive);
+        this.toDispose.push(this.aiActivationService.onDidChangeCanRun(() => {
+            this.setEnabled(this.aiActivationService.canRun);
         }));
         this.toDispose.push(this.chatAgentService.onDefaultAgentChanged(() => {
             this.scheduleUpdateReceivingAgent();
@@ -437,15 +585,58 @@ let AIChatInputWidget = class AIChatInputWidget extends browser_2.ReactWidget {
                 this.updateReceivingAgentTimeout = undefined;
             }
         }));
-        this.setEnabled(this.aiActivationService.isActive);
+        this.setEnabled(this.aiActivationService.canRun);
         this.historyService.init().then(() => {
             this.navigationState = new chat_input_history_1.ChatInputNavigationState(this.historyService);
         });
         this.initializeContextKeys();
+        this.tokenUsageEnabled = this.preferenceService?.get(chat_view_preferences_1.CHAT_VIEW_TOKEN_USAGE_ENABLED, false) ?? false;
+        if (this.preferenceService) {
+            this.toDispose.push(this.preferenceService.onPreferenceChanged(change => {
+                if (change.preferenceName === chat_view_preferences_1.CHAT_VIEW_TOKEN_USAGE_ENABLED) {
+                    this.tokenUsageEnabled = this.preferenceService?.get(chat_view_preferences_1.CHAT_VIEW_TOKEN_USAGE_ENABLED, false) ?? false;
+                    this.update();
+                }
+                else if (change.preferenceName === ai_core_1.PREFERENCE_NAME_REASONING) {
+                    // Refresh the reasoning selector display when the default preference changes.
+                    this.update();
+                }
+                else if (change.preferenceName === chat_view_preferences_1.CHAT_VIEW_TOKEN_USAGE_WARNING_THRESHOLD_PERCENTAGE) {
+                    // Threshold changed: clear notified sessions so users are warned again
+                    // at the new threshold (e.g. after raising it from the warning's
+                    // "Open Settings" action), and re-evaluate the current session so the
+                    // warning appears immediately if it's still above the new threshold.
+                    this.notifiedSessions.clear();
+                    if (this._chatModel) {
+                        this.evaluateTokenUsageWarning(this._chatModel);
+                    }
+                    // Re-render so the indicator's color bands reflect the new threshold.
+                    this.update();
+                }
+                else if (change.preferenceName === chat_view_preferences_1.CHAT_VIEW_TOKEN_USAGE_WARNING_ENABLED && this._chatModel) {
+                    // If the user just enabled warnings for a session already above threshold,
+                    // evaluate now so they get an immediate notification instead of waiting for
+                    // the next response.
+                    this.evaluateTokenUsageWarning(this._chatModel);
+                }
+            }));
+        }
         // Listen for prompt fragment changes to refresh capabilities
         this.toDispose.push(this.capabilitiesService.onDidChangeCapabilities(() => {
             this.refreshCapabilities();
         }));
+        // Refresh reasoning capability if the language model registry changes (model added/removed/alias re-resolved).
+        this.toDispose.push(this.languageModelRegistry.onChange(() => {
+            if (this.receivingAgent) {
+                this.updateReasoningSupport(this.receivingAgent.agentId);
+            }
+        }));
+        // When the default mode changes externally (e.g. via AI Configuration),
+        // sync the mode selector. Deferred via queueMicrotask so the prompt service's
+        // internal state is fully updated before we read agent.modes.
+        this.toDispose.push(this.promptService.onSelectedVariantChange(() => {
+            queueMicrotask(() => this.syncSelectedModeWithDefault());
+        }));
         // Listen for generic capabilities changes
         if (this.genericCapabilitiesService) {
             this.updateAvailableGenericCapabilities();
@@ -490,6 +681,79 @@ let AIChatInputWidget = class AIChatInputWidget extends browser_2.ReactWidget {
         this.chatInputFirstLineKey.set(isFirstVisualOverall);
         this.chatInputLastLineKey.set(isLastVisualOverall);
     }
+    /**
+     * Resolve the configured token usage warning threshold as an absolute token count.
+     * The preference is stored as a percentage of the context window; this method
+     * converts it using the current assumed context window size.
+     */
+    getTokenUsageWarningThreshold() {
+        const percentage = this.getTokenUsageWarningThresholdPercentage();
+        return Math.round((percentage / 100) * chat_token_usage_indicator_util_1.CHAT_CONTEXT_WINDOW_SIZE);
+    }
+    getTokenUsageWarningThresholdPercentage() {
+        const value = this.preferenceService?.get(chat_view_preferences_1.CHAT_VIEW_TOKEN_USAGE_WARNING_THRESHOLD_PERCENTAGE, chat_view_preferences_1.CHAT_VIEW_TOKEN_USAGE_WARNING_THRESHOLD_PERCENTAGE_DEFAULT);
+        if (typeof value !== 'number' || !Number.isFinite(value) || value < 1 || value > 100) {
+            return chat_view_preferences_1.CHAT_VIEW_TOKEN_USAGE_WARNING_THRESHOLD_PERCENTAGE_DEFAULT;
+        }
+        return value;
+    }
+    isTokenUsageWarningEnabled() {
+        return this.preferenceService?.get(chat_view_preferences_1.CHAT_VIEW_TOKEN_USAGE_WARNING_ENABLED, false) ?? false;
+    }
+    /**
+     * Called after a response changes on the currently attached session. Shows a
+     * warning the first time the total crosses the threshold, and re-arms when
+     * usage drops back below it.
+     */
+    evaluateTokenUsageWarning(chatModel) {
+        // No point doing any work if the feature is off.
+        if (!this.isTokenUsageWarningEnabled()) {
+            return;
+        }
+        // `responseChanged` fires on every streaming tick, but providers typically
+        // only set `tokenUsage` at completion. Skip in-progress responses so we do
+        // the walk + decision once per response rather than per chunk.
+        const lastRequest = chatModel.getRequests().at(-1);
+        if (lastRequest && !lastRequest.response.isComplete) {
+            return;
+        }
+        const decision = (0, chat_token_usage_indicator_util_1.decideTokenUsageWarning)({
+            totalTokens: (0, chat_token_usage_indicator_util_1.computeSessionTokenUsage)(chatModel),
+            threshold: this.getTokenUsageWarningThreshold(),
+            alreadyNotified: this.notifiedSessions.has(chatModel.id)
+        });
+        if (decision === 'reset') {
+            this.notifiedSessions.delete(chatModel.id);
+        }
+        else if (decision === 'notify') {
+            this.notifiedSessions.add(chatModel.id);
+            this.showTokenUsageWarning();
+        }
+    }
+    async showTokenUsageWarning() {
+        const percentage = this.getTokenUsageWarningThresholdPercentage();
+        const message = core_1.nls.localize('theia/ai/chat-ui/tokenUsageWarningMessage', 'Chat session token usage has reached {0}% of the context window. ' +
+            'Consider summarizing this session or starting a new one to avoid hitting the limit.', percentage);
+        const summarizeAction = core_1.nls.localize('theia/ai/chat-ui/tokenUsageWarningSummarizeAction', 'Summarize Current Session');
+        const newSessionAction = core_1.nls.localize('theia/ai/chat-ui/tokenUsageWarningNewSessionAction', 'Start New Chat');
+        const openSettingsAction = core_1.nls.localizeByDefault('Open Settings');
+        const selected = await this.messageService.warn(message, summarizeAction, newSessionAction, openSettingsAction);
+        if (selected === summarizeAction) {
+            this.commandService.executeCommand(chat_view_commands_1.ChatCommands.AI_CHAT_NEW_WITH_TASK_CONTEXT.id).catch(error => {
+                console.error(`Failed to execute '${chat_view_commands_1.ChatCommands.AI_CHAT_NEW_WITH_TASK_CONTEXT.id}' from token usage warning`, error);
+            });
+        }
+        else if (selected === newSessionAction) {
+            this.commandService.executeCommand(chat_view_commands_1.AI_CHAT_NEW_CHAT_WINDOW_COMMAND.id).catch(error => {
+                console.error(`Failed to execute '${chat_view_commands_1.AI_CHAT_NEW_CHAT_WINDOW_COMMAND.id}' from token usage warning`, error);
+            });
+        }
+        else if (selected === openSettingsAction) {
+            this.commandService.executeCommand(browser_2.CommonCommands.OPEN_PREFERENCES.id, chat_view_preferences_1.CHAT_VIEW_TOKEN_USAGE_WARNING_THRESHOLD_PERCENTAGE).catch(error => {
+                console.error(`Failed to execute '${browser_2.CommonCommands.OPEN_PREFERENCES.id}' from token usage warning`, error);
+            });
+        }
+    }
     scheduleUpdateReceivingAgent() {
         if (this.queryInFlight) {
             // Don't update capabilities while a query is being sent — the editor is being
@@ -571,7 +835,11 @@ let AIChatInputWidget = class AIChatInputWidget extends browser_2.ReactWidget {
         if (agent && (agentId !== previousAgentId || needsRefresh)) {
             const modes = agent.modes ?? [];
             const defaultMode = modes.find(m => m.isDefault);
-            const initialModeId = defaultMode?.id;
+            const hasPreviousRequests = this._chatModel.getRequests().length > 0;
+            const restoredModeId = needsRefresh && hasPreviousRequests
+                ? this.getLastModeIdFromModel(this._chatModel)
+                : undefined;
+            const initialModeId = restoredModeId ?? defaultMode?.id;
             this.receivingAgent = {
                 agentId: agentId,
                 modes,
@@ -579,15 +847,39 @@ let AIChatInputWidget = class AIChatInputWidget extends browser_2.ReactWidget {
             };
             this.chatInputHasModesKey.set(modes.length > 1);
             // Only preserve overrides on forced refresh if the session has previous requests
-            const hasPreviousRequests = this._chatModel.getRequests().length > 0;
             const shouldPreserveOverrides = needsRefresh && hasPreviousRequests;
             await this.updateCapabilitiesForAgent(agentId, initialModeId, shouldPreserveOverrides);
+            this.updateReasoningSupport(agentId);
         }
         else if (!agent && this.receivingAgent !== undefined) {
             this.receivingAgent = undefined;
             this.capabilityDefaults = [];
             this.userCapabilityOverrides = new Map();
             this.chatInputHasModesKey.set(false);
+            this.currentReasoningSupport = undefined;
+            this.update();
+        }
+    }
+    /**
+     * Syncs the selected mode in the UI with the agent's current default mode.
+     * Called when the default mode changes externally (e.g. via AI Configuration).
+     */
+    syncSelectedModeWithDefault() {
+        if (!this.receivingAgent) {
+            return;
+        }
+        const agent = this.chatAgentService.getAgent(this.receivingAgent.agentId);
+        if (!agent?.modes) {
+            return;
+        }
+        const updatedModes = agent.modes;
+        const newDefault = updatedModes.find(m => m.isDefault);
+        if (newDefault && newDefault.id !== this.receivingAgent.currentModeId) {
+            this.receivingAgent = {
+                ...this.receivingAgent,
+                modes: updatedModes,
+                currentModeId: newDefault.id
+            };
             this.update();
         }
     }
@@ -698,6 +990,10 @@ let AIChatInputWidget = class AIChatInputWidget extends browser_2.ReactWidget {
                 currentMode: this.receivingAgent?.currentModeId,
                 onModeChange: this.handleModeChange,
                 keybindingHint: this.getModeKeybindingHint(),
+            }, reasoningSelectorProps: {
+                reasoningSupport: this.currentReasoningSupport,
+                currentLevel: this.getCurrentReasoningLevel(),
+                onReasoningChange: this.handleReasoningChange,
             }, capabilitiesProps: {
                 capabilities: this.capabilityDefaults,
                 overrides: this.userCapabilityOverrides,
@@ -714,7 +1010,7 @@ let AIChatInputWidget = class AIChatInputWidget extends browser_2.ReactWidget {
                 availableCapabilities: this.availableGenericCapabilities,
                 disabledCapabilities: this.disabledGenericCapabilities,
                 hoverService: this.hoverService,
-            } }));
+            }, tokenUsageEnabled: this.tokenUsageEnabled, tokenUsageWarningThreshold: this.getTokenUsageWarningThreshold() }));
     }
     onDragOver(event) {
         event.preventDefault();
@@ -1051,6 +1347,27 @@ tslib_1.__decorate([
     (0, inversify_1.inject)(common_1.AISettingsService),
     tslib_1.__metadata("design:type", Object)
 ], AIChatInputWidget.prototype, "aiSettingsService", void 0);
+tslib_1.__decorate([
+    (0, inversify_1.inject)(common_1.PromptService),
+    tslib_1.__metadata("design:type", Object)
+], AIChatInputWidget.prototype, "promptService", void 0);
+tslib_1.__decorate([
+    (0, inversify_1.inject)(ai_core_1.FrontendLanguageModelRegistry),
+    tslib_1.__metadata("design:type", Object)
+], AIChatInputWidget.prototype, "languageModelRegistry", void 0);
+tslib_1.__decorate([
+    (0, inversify_1.inject)(preferences_1.PreferenceService),
+    (0, inversify_1.optional)(),
+    tslib_1.__metadata("design:type", Object)
+], AIChatInputWidget.prototype, "preferenceService", void 0);
+tslib_1.__decorate([
+    (0, inversify_1.inject)(core_1.MessageService),
+    tslib_1.__metadata("design:type", core_1.MessageService)
+], AIChatInputWidget.prototype, "messageService", void 0);
+tslib_1.__decorate([
+    (0, inversify_1.inject)(core_1.CommandService),
+    tslib_1.__metadata("design:type", Object)
+], AIChatInputWidget.prototype, "commandService", void 0);
 tslib_1.__decorate([
     (0, inversify_1.postConstruct)(),
     tslib_1.__metadata("design:type", Function),
@@ -1413,22 +1730,37 @@ const ChatInput = (props) => {
     const contextUI = buildContextUI(props.context, props.labelProvider, props.onDeleteContextElement, props.onOpenContextElement, props.fileValidationState);
     // Show mode selector if agent has multiple modes
     const showModeSelector = (props.modeSelectorProps.receivingAgentModes?.length ?? 0) > 1;
+    // Token usage computation (cheap pure function walking the model's request list)
+    const totalTokens = props.tokenUsageEnabled ? (0, chat_token_usage_indicator_util_1.computeSessionTokenUsage)(props.chatModel) : 0;
+    const showTokenUsage = props.tokenUsageEnabled && totalTokens > 0;
+    const tokenColorClass = showTokenUsage ? (0, chat_token_usage_indicator_util_1.getUsageColorClass)(totalTokens, props.tokenUsageWarningThreshold) : '';
+    const tokenIsWarningOrError = tokenColorClass === 'token-usage-yellow' || tokenColorClass === 'token-usage-red';
+    const tokenTooltip = showTokenUsage ? (0, chat_token_usage_indicator_util_1.buildBarTooltip)((0, chat_token_usage_indicator_util_1.getLatestTokenUsage)(props.chatModel), totalTokens, props.tokenUsageWarningThreshold) : undefined;
     return (React.createElement("div", { className: "theia-ChatInput", "data-ai-disabled": !props.isEnabled, onDragOver: props.onDragOver, onDrop: props.onDrop, ref: containerRef },
         props.showSuggestions !== false && React.createElement(chat_input_agent_suggestions_1.ChatInputAgentSuggestions, { suggestions: props.suggestions, opener: props.openerService }),
         props.showChangeSet && changeSetUI?.elements &&
             React.createElement(ChangeSetBox, { changeSet: changeSetUI }),
-        React.createElement("div", { className: 'theia-ChatInput-Editor-Box' },
+        React.createElement("div", { className: `theia-ChatInput-Editor-Box${tokenIsWarningOrError ? ` token-usage-border-${tokenColorClass}` : ''}` },
             props.showCapabilities !== false && (React.createElement(CapabilitiesBar, { isOpen: props.capabilitiesProps.isOpen, capabilities: props.capabilitiesProps.capabilities, overrides: props.capabilitiesProps.overrides, onCapabilityChange: props.capabilitiesProps.onCapabilityChange, genericCapabilities: props.genericCapabilitiesProps.genericCapabilities, onGenericCapabilityChange: props.genericCapabilitiesProps.onGenericCapabilityChange, onResetGenericCapabilities: props.genericCapabilitiesProps.onResetGenericCapabilities, availableCapabilities: props.genericCapabilitiesProps.availableCapabilities, disabledCapabilities: props.genericCapabilitiesProps.disabledCapabilities, disabled: !props.isEnabled, hoverService: props.hoverService, hasUnsavedChanges: props.capabilitiesProps.hasUnsavedChanges, onSaveToSettings: props.capabilitiesProps.onSaveToSettings })),
             React.createElement("div", { className: 'theia-ChatInput-Editor', ref: editorContainerRef, onKeyDown: onKeyDown, onFocus: handleInputFocus, onBlur: handleInputBlur },
                 React.createElement("div", { ref: placeholderRef, className: 'theia-ChatInput-Editor-Placeholder' }, placeholderText)),
             props.context && props.context.length > 0 &&
                 React.createElement(ChatContext, { context: contextUI.context }),
-            React.createElement(ChatInputOptions, { leftOptions: leftOptions, rightOptions: rightOptions, isEnabled: props.isEnabled, hoverService: props.hoverService, modeSelectorProps: {
+            React.createElement(ChatInputOptions, { leftOptions: leftOptions, rightOptions: rightOptions, isEnabled: props.isEnabled, hoverService: props.hoverService, tokenUsage: showTokenUsage ? {
+                    percent: Math.min((totalTokens / chat_token_usage_indicator_util_1.CHAT_CONTEXT_WINDOW_SIZE) * 100, 100),
+                    colorClass: tokenColorClass,
+                    tooltip: tokenTooltip,
+                } : undefined, modeSelectorProps: {
                     show: showModeSelector,
                     modes: props.modeSelectorProps.receivingAgentModes,
                     currentMode: props.modeSelectorProps.currentMode,
                     onModeChange: props.modeSelectorProps.onModeChange,
                     keybindingHint: props.modeSelectorProps.keybindingHint,
+                }, reasoningSelectorProps: {
+                    show: !!props.reasoningSelectorProps.reasoningSupport,
+                    reasoningSupport: props.reasoningSelectorProps.reasoningSupport,
+                    currentLevel: props.reasoningSelectorProps.currentLevel,
+                    onReasoningChange: props.reasoningSelectorProps.onReasoningChange,
                 }, capabilitiesToggle: {
                     show: props.showCapabilities !== false,
                     isOpen: props.capabilitiesProps.isOpen,
@@ -1442,16 +1774,16 @@ const ChatInput = (props) => {
 /**
  * Returns an onMouseEnter handler that shows a hover tooltip via HoverService.
  */
-function hoverHandler(hoverService, content) {
+function hoverHandler(hoverService, content, position = 'bottom') {
     return (e) => {
         hoverService.requestHover({
             content,
             target: e.currentTarget,
-            position: 'bottom'
+            position
         });
     };
 }
-const ChatInputOptions = ({ leftOptions, rightOptions, isEnabled, hoverService, modeSelectorProps, capabilitiesToggle }) => {
+const ChatInputOptions = ({ leftOptions, rightOptions, isEnabled, hoverService, tokenUsage, modeSelectorProps, reasoningSelectorProps, capabilitiesToggle }) => {
     const capabilitiesLabel = core_1.nls.localize('theia/ai/chat-ui/toggleCapabilitiesConfig', 'Toggle Capabilities Configuration');
     const capabilitiesTitle = capabilitiesToggle.keybindingHint
         ? `${capabilitiesLabel} (${capabilitiesToggle.keybindingHint})`
@@ -1460,14 +1792,20 @@ const ChatInputOptions = ({ leftOptions, rightOptions, isEnabled, hoverService,
     // Right options are rendered first in DOM for tab order (send button first when enabled)
     // CSS order property positions them visually (left on left, right on right)
     React.createElement("div", { className: "theia-ChatInputOptions" },
-        React.createElement("div", { className: "theia-ChatInputOptions-right" }, rightOptions.map((option, index) => (React.createElement("span", { key: index, className: `option${option.disabled ? ' disabled' : ''}${option.text?.align === 'right' ? ' reverse' : ''}`, "aria-label": option.title, role: 'button', tabIndex: option.disabled ? -1 : 0, onClick: option.handler, onMouseEnter: hoverHandler(hoverService, option.title), onKeyDown: e => {
-                if (e.key === 'Enter' || e.key === ' ') {
-                    e.preventDefault();
-                    option.handler();
-                }
-            } },
-            React.createElement("span", null, option.text?.content),
-            React.createElement("span", { className: `codicon ${option.className}` }))))),
+        React.createElement("div", { className: "theia-ChatInputOptions-right" },
+            tokenUsage && (React.createElement("span", { className: `token-usage-badge ${tokenUsage.colorClass}`, ...(tokenUsage.tooltip && { onMouseEnter: hoverHandler(hoverService, tokenUsage.tooltip, 'top') }) },
+                React.createElement("span", { className: 'token-usage-ring', style: {
+                        background: `conic-gradient(var(--token-usage-fill) ${tokenUsage.percent}%, var(--token-usage-track) ${tokenUsage.percent}%)`
+                    } },
+                    React.createElement("span", { className: 'token-usage-ring-inner' })))),
+            rightOptions.map((option, index) => (React.createElement("span", { key: index, className: `option${option.disabled ? ' disabled' : ''}${option.text?.align === 'right' ? ' reverse' : ''}`, "aria-label": option.title, role: 'button', tabIndex: option.disabled ? -1 : 0, onClick: option.handler, onMouseEnter: hoverHandler(hoverService, option.title), onKeyDown: e => {
+                    if (e.key === 'Enter' || e.key === ' ') {
+                        e.preventDefault();
+                        option.handler();
+                    }
+                } },
+                React.createElement("span", null, option.text?.content),
+                React.createElement("span", { className: `codicon ${option.className}` }))))),
         React.createElement("div", { className: "theia-ChatInputOptions-left" },
             leftOptions.map((option, index) => (React.createElement("span", { key: index, className: `option${option.disabled ? ' disabled' : ''}${option.text?.align === 'right' ? ' reverse' : ''}`, "aria-label": option.title, role: 'button', tabIndex: option.disabled ? -1 : 0, onClick: option.handler, onMouseEnter: hoverHandler(hoverService, option.title), onKeyDown: e => {
                     if (e.key === 'Enter' || e.key === ' ') {
@@ -1485,7 +1823,8 @@ const ChatInputOptions = ({ leftOptions, rightOptions, isEnabled, hoverService,
                     }
                 } },
                 React.createElement("span", { className: "codicon codicon-tools" }),
-                capabilitiesToggle.hasUnsavedChanges && (React.createElement("span", { className: "theia-capabilities-unsaved-indicator" })))))));
+                capabilitiesToggle.hasUnsavedChanges && (React.createElement("span", { className: "theia-capabilities-unsaved-indicator" })))),
+            reasoningSelectorProps.show && reasoningSelectorProps.reasoningSupport && (React.createElement(ReasoningSelector, { reasoningSupport: reasoningSelectorProps.reasoningSupport, currentLevel: reasoningSelectorProps.currentLevel, onReasoningChange: reasoningSelectorProps.onReasoningChange, disabled: !isEnabled, hoverService: hoverService })))));
 };
 /**
  * Combined capabilities bar that shows:
@@ -1530,6 +1869,28 @@ const ChatModeSelector = React.memo(({ modes, currentMode, onModeChange, disable
     return (React.createElement("span", { onMouseEnter: hoverHandler(hoverService, title) },
         React.createElement(select_component_1.SelectComponent, { className: `theia-ChatInput-ModeSelector${disabled ? ' disabled' : ''}`, options: options, defaultValue: currentMode ?? modes[0]?.id ?? '', onChange: handleChange })));
 });
+const reasoningLevelLabel = (level) => {
+    switch (level) {
+        case 'off': return core_1.nls.localizeByDefault('Off');
+        case 'minimal': return core_1.nls.localize('theia/ai/chat-ui/reasoning/minimal', 'Minimal');
+        case 'low': return core_1.nls.localize('theia/ai/chat-ui/reasoning/low', 'Low');
+        case 'medium': return core_1.nls.localize('theia/ai/chat-ui/reasoning/medium', 'Medium');
+        case 'high': return core_1.nls.localize('theia/ai/chat-ui/reasoning/high', 'High');
+        case 'auto': return core_1.nls.localizeByDefault('Auto');
+    }
+};
+const ReasoningSelector = React.memo(({ reasoningSupport, currentLevel, onReasoningChange, disabled, hoverService }) => {
+    const options = React.useMemo(() => reasoningSupport.supportedLevels.map(level => ({ value: level, label: reasoningLevelLabel(level) })), [reasoningSupport]);
+    const handleChange = React.useCallback((option) => {
+        if (option.value) {
+            onReasoningChange(option.value);
+        }
+    }, [onReasoningChange]);
+    const title = core_1.nls.localizeByDefault('Reasoning');
+    const effectiveLevel = currentLevel ?? reasoningSupport.defaultLevel ?? reasoningSupport.supportedLevels[0] ?? 'off';
+    return (React.createElement("span", { onMouseEnter: hoverHandler(hoverService, title) },
+        React.createElement(select_component_1.SelectComponent, { className: `theia-ChatInput-ReasoningSelector reasoning-level-${effectiveLevel}${disabled ? ' disabled' : ''}`, options: options, defaultValue: effectiveLevel, onChange: handleChange })));
+});
 const noPropagation = (handler) => (e) => {
     handler();
     e.stopPropagation();