@codingame/monaco-vscode-chat-service-override 26.2.2 → 28.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/tools/usagesTool.js

@@ -0,0 +1,311 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { escapeRegExpCharacters } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { relativePath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { Position } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
+import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
+import { getDefinitionsAtPosition, getReferencesAtPosition, getImplementationsAtPosition } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/gotoSymbol/browser/goToSymbol';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { QueryType, resultIsMatch } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/search';
+import { ISearchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/search.service';
+import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
+import { createToolSimpleTextResult } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/builtinTools/toolHelpers';
+import { resolveToolUri, errorResult, findLineNumber, findSymbolColumn } from './toolHelpers.js';
+
+const UsagesToolId = "vscode_listCodeUsages";
+const BaseModelDescription = `Find all usages (references, definitions, and implementations) of a code symbol across the workspace. This tool locates where a symbol is referenced, defined, or implemented.
+
+Input:
+- "symbol": The exact name of the symbol to search for (function, class, method, variable, type, etc.).
+- "uri": A full URI (e.g. "file:///path/to/file.ts") of a file where the symbol appears. Provide either "uri" or "filePath".
+- "filePath": A workspace-relative file path (e.g. "src/utils/helpers.ts") of a file where the symbol appears. Provide either "uri" or "filePath".
+- "lineContent": A substring of the line of code where the symbol appears. This is used to locate the exact position in the file. Must be the actual text from the file - do NOT fabricate it.
+
+IMPORTANT: The file and line do NOT need to be the definition of the symbol. Any occurrence works - a usage, an import, a call site, etc. You can pick whichever occurrence is most convenient.
+
+If the tool returns an error, retry with corrected input - ensure the file path is correct, the line content matches the actual file content, and the symbol name appears in that line.`;
+let UsagesTool = class UsagesTool extends Disposable {
+    constructor(
+        _languageFeaturesService,
+        _modelService,
+        _searchService,
+        _textModelService,
+        _workspaceContextService
+    ) {
+        super();
+        this._languageFeaturesService = _languageFeaturesService;
+        this._modelService = _modelService;
+        this._searchService = _searchService;
+        this._textModelService = _textModelService;
+        this._workspaceContextService = _workspaceContextService;
+        this._onDidUpdateToolData = this._store.add(( new Emitter()));
+        this.onDidUpdateToolData = this._onDidUpdateToolData.event;
+        this._store.add(Event.debounce(
+            this._languageFeaturesService.referenceProvider.onDidChange,
+            () => {},
+            2000
+        )((() => this._onDidUpdateToolData.fire())));
+    }
+    getToolData() {
+        const languageIds = this._languageFeaturesService.referenceProvider.registeredLanguageIds;
+        let modelDescription = BaseModelDescription;
+        if (( languageIds.has("*"))) {
+            modelDescription += "\n\nSupported for all languages.";
+        } else if (languageIds.size > 0) {
+            const sorted = [...languageIds].sort();
+            modelDescription += `\n\nCurrently supported for: ${sorted.join(", ")}.`;
+        } else {
+            modelDescription += "\n\nNo languages currently have reference providers registered.";
+        }
+        return {
+            id: UsagesToolId,
+            toolReferenceName: "usages",
+            canBeReferencedInPrompt: false,
+            icon: ThemeIcon.fromId(Codicon.references.id),
+            displayName: ( localize(6478, "List Code Usages")),
+            userDescription: ( localize(6479, "Find references, definitions, and implementations of a symbol")),
+            modelDescription,
+            source: ToolDataSource.Internal,
+            when: ( ContextKeyExpr.has("config.chat.tools.usagesTool.enabled")),
+            inputSchema: {
+                type: "object",
+                properties: {
+                    symbol: {
+                        type: "string",
+                        description: "The exact name of the symbol (function, class, method, variable, type, etc.) to find usages of."
+                    },
+                    uri: {
+                        type: "string",
+                        description: "A full URI of a file where the symbol appears (e.g. \"file:///path/to/file.ts\"). Provide either \"uri\" or \"filePath\"."
+                    },
+                    filePath: {
+                        type: "string",
+                        description: "A workspace-relative file path where the symbol appears (e.g. \"src/utils/helpers.ts\"). Provide either \"uri\" or \"filePath\"."
+                    },
+                    lineContent: {
+                        type: "string",
+                        description: "A substring of the line of code where the symbol appears. Used to locate the exact position. Must be actual text from the file."
+                    }
+                },
+                required: ["symbol", "lineContent"]
+            }
+        };
+    }
+    async prepareToolInvocation(context, _token) {
+        const input = context.parameters;
+        return {
+            invocationMessage: ( localize(6480, "Analyzing usages of `{0}`", input.symbol))
+        };
+    }
+    async invoke(invocation, _countTokens, _progress, token) {
+        const input = invocation.parameters;
+        const uri = resolveToolUri(input, this._workspaceContextService);
+        if (!uri) {
+            return errorResult(
+                "Provide either \"uri\" (a full URI) or \"filePath\" (a workspace-relative path) to identify the file."
+            );
+        }
+        const ref = await this._textModelService.createModelReference(uri);
+        try {
+            const model = ref.object.textEditorModel;
+            if (!( this._languageFeaturesService.referenceProvider.has(model))) {
+                return errorResult(
+                    `No reference provider available for this file's language. The usages tool may not support this language.`
+                );
+            }
+            const lineNumber = findLineNumber(model, input.lineContent);
+            if (lineNumber === undefined) {
+                return errorResult(`Could not find line content "${input.lineContent}" in ${( uri.toString())}. Provide the exact text from the line where the symbol appears.`);
+            }
+            const lineText = model.getLineContent(lineNumber);
+            const column = findSymbolColumn(lineText, input.symbol);
+            if (column === undefined) {
+                return errorResult(
+                    `Could not find symbol "${input.symbol}" in the matched line. Ensure the symbol name is correct and appears in the provided line content.`
+                );
+            }
+            const position = ( new Position(lineNumber, column));
+            const [definitions, references, implementations] = await Promise.all([getDefinitionsAtPosition(
+                this._languageFeaturesService.definitionProvider,
+                model,
+                position,
+                false,
+                token
+            ), getReferencesAtPosition(
+                this._languageFeaturesService.referenceProvider,
+                model,
+                position,
+                false,
+                false,
+                token
+            ), getImplementationsAtPosition(
+                this._languageFeaturesService.implementationProvider,
+                model,
+                position,
+                false,
+                token
+            )]);
+            if (references.length === 0) {
+                const result = createToolSimpleTextResult(`No usages found for \`${input.symbol}\`.`);
+                result.toolResultMessage = ( new MarkdownString(( localize(6481, "Analyzed usages of `{0}`, no results", input.symbol))));
+                return result;
+            }
+            const previews = await this._getLinePreviews(input.symbol, references, token);
+            const lines = [];
+            lines.push(`${references.length} usages of \`${input.symbol}\`:\n`);
+            for (let i = 0; i < references.length; i++) {
+                const ref = references[i];
+                const kind = this._classifyReference(ref, definitions, implementations);
+                const startLine = Range.lift(ref.range).startLineNumber;
+                const preview = previews[i];
+                if (preview) {
+                    lines.push(`<usage type="${kind}" uri="${( ref.uri.toString())}" line="${startLine}">`);
+                    lines.push(`\t${preview}`);
+                    lines.push(`</usage>`);
+                } else {
+                    lines.push(`<usage type="${kind}" uri="${( ref.uri.toString())}" line="${startLine}" />`);
+                }
+            }
+            const text = lines.join("\n");
+            const result = createToolSimpleTextResult(text);
+            result.toolResultMessage = references.length === 1 ? ( new MarkdownString(( localize(6482, "Analyzed usages of `{0}`, 1 result", input.symbol)))) : ( new MarkdownString(( localize(
+                6483,
+                "Analyzed usages of `{0}`, {1} results",
+                input.symbol,
+                references.length
+            ))));
+            result.toolResultDetails = ( references.map(r => ({
+                uri: r.uri,
+                range: r.range
+            })));
+            return result;
+        } finally {
+            ref.dispose();
+        }
+    }
+    async _getLinePreviews(symbol, references, token) {
+        const previews = ( new Array(references.length));
+        const lookup = ( new Map());
+        const needSearch = ( new ResourceSet());
+        for (let i = 0; i < references.length; i++) {
+            const ref = references[i];
+            const lineNumber = Range.lift(ref.range).startLineNumber;
+            const existingModel = this._modelService.getModel(ref.uri);
+            if (existingModel) {
+                previews[i] = existingModel.getLineContent(lineNumber).trim();
+            } else {
+                lookup.set(`${( ref.uri.toString())}:${lineNumber}`, i);
+                needSearch.add(ref.uri);
+            }
+        }
+        if (needSearch.size === 0 || token.isCancellationRequested) {
+            return previews;
+        }
+        try {
+            const folders = this._workspaceContextService.getWorkspace().folders;
+            const relativePaths = [];
+            for (const uri of needSearch) {
+                const folder = this._workspaceContextService.getWorkspaceFolder(uri);
+                if (folder) {
+                    const rel = relativePath(folder.uri, uri);
+                    if (rel) {
+                        relativePaths.push(rel);
+                    }
+                }
+            }
+            if (relativePaths.length > 0) {
+                const includePattern = {};
+                if (relativePaths.length === 1) {
+                    includePattern[relativePaths[0]] = true;
+                } else {
+                    includePattern[`{${relativePaths.join(",")}}`] = true;
+                }
+                const searchResult = await this._searchService.textSearch({
+                    type: QueryType.Text,
+                    contentPattern: {
+                        pattern: escapeRegExpCharacters(symbol),
+                        isRegExp: true,
+                        isWordMatch: true
+                    },
+                    folderQueries: ( folders.map(f => ({
+                        folder: f.uri
+                    }))),
+                    includePattern
+                }, token);
+                for (const fileMatch of searchResult.results) {
+                    if (!fileMatch.results) {
+                        continue;
+                    }
+                    for (const textMatch of fileMatch.results) {
+                        if (!resultIsMatch(textMatch)) {
+                            continue;
+                        }
+                        for (const range of textMatch.rangeLocations) {
+                            const lineNumber = range.source.startLineNumber + 1;
+                            const key = `${( fileMatch.resource.toString())}:${lineNumber}`;
+                            const idx = lookup.get(key);
+                            if (idx !== undefined) {
+                                previews[idx] = textMatch.previewText.trim();
+                                lookup.delete(key);
+                            }
+                        }
+                    }
+                }
+            }
+        } catch {}
+        return previews;
+    }
+    _classifyReference(ref, definitions, implementations) {
+        if (( definitions.some(d => this._overlaps(ref, d)))) {
+            return "definition";
+        }
+        if (( implementations.some(d => this._overlaps(ref, d)))) {
+            return "implementation";
+        }
+        return "reference";
+    }
+    _overlaps(a, b) {
+        if (( a.uri.toString()) !== ( b.uri.toString())) {
+            return false;
+        }
+        return Range.areIntersectingOrTouching(a.range, b.range);
+    }
+};
+UsagesTool = ( __decorate([( __param(0, ILanguageFeaturesService)), ( __param(1, IModelService)), ( __param(2, ISearchService)), ( __param(3, ITextModelService)), ( __param(4, IWorkspaceContextService))], UsagesTool));
+let UsagesToolContribution = class UsagesToolContribution extends Disposable {
+    static {
+        this.ID = "chat.usagesTool";
+    }
+    constructor(toolsService, instantiationService) {
+        super();
+        const usagesTool = this._store.add(instantiationService.createInstance(UsagesTool));
+        let registration;
+        const registerUsagesTool = () => {
+            registration?.dispose();
+            toolsService.flushToolUpdates();
+            const toolData = usagesTool.getToolData();
+            registration = toolsService.registerTool(toolData, usagesTool);
+        };
+        registerUsagesTool();
+        this._store.add(usagesTool.onDidUpdateToolData(registerUsagesTool));
+        this._store.add({
+            dispose: () => registration?.dispose()
+        });
+    }
+};
+UsagesToolContribution = ( __decorate([( __param(0, ILanguageModelToolsService)), ( __param(1, IInstantiationService))], UsagesToolContribution));
+
+export { UsagesTool, UsagesToolContribution, UsagesToolId };

package/vscode/src/vs/workbench/contrib/chat/browser/viewsWelcome/chatViewsWelcomeHandler.js

@@ -17,29 +17,29 @@ const chatViewsWelcomeJsonSchema = {
     properties: {
         icon: {
             type: "string",
-            description: ( localize(5890, "The icon for the welcome message."))
+            description: ( localize(6484, "The icon for the welcome message."))
         },
         title: {
             type: "string",
-            description: ( localize(5891, "The title of the welcome message."))
+            description: ( localize(6485, "The title of the welcome message."))
         },
         content: {
             type: "string",
             description: ( localize(
-                5892,
+                6486,
                 "The content of the welcome message. The first command link will be rendered as a button."
             ))
         },
         when: {
             type: "string",
-            description: ( localize(5893, "Condition when the welcome message is shown."))
+            description: ( localize(6487, "Condition when the welcome message is shown."))
         }
     }
 };
 const chatViewsWelcomeExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: "chatViewsWelcome",
     jsonSchema: {
-        description: ( localize(5894, "Contributes a welcome message to a chat view")),
+        description: ( localize(6488, "Contributes a welcome message to a chat view")),
         type: "array",
         items: chatViewsWelcomeJsonSchema
     }

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatWidgetService.d.ts

@@ -26,6 +26,10 @@ export declare class ChatWidgetService extends Disposable implements IChatWidget
     readonly onDidAddWidget: Event<IChatWidget>;
     private readonly _onDidBackgroundSession;
     readonly onDidBackgroundSession: Event<URI>;
+    private readonly _onDidChangeFocusedWidget;
+    readonly onDidChangeFocusedWidget: Event<IChatWidget | undefined>;
+    private readonly _onDidChangeFocusedSession;
+    readonly onDidChangeFocusedSession: Event<void>;
     constructor(editorGroupsService: IEditorGroupsService, viewsService: IViewsService, quickChatService: IQuickChatService, layoutService: ILayoutService, editorService: IEditorService, chatService: IChatService);
     get lastFocusedWidget(): IChatWidget | undefined;
     getAllWidgets(): ReadonlyArray<IChatWidget>;

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatWidgetService.js

@@ -39,6 +39,10 @@ let ChatWidgetService = class ChatWidgetService extends Disposable {
         this.onDidAddWidget = this._onDidAddWidget.event;
         this._onDidBackgroundSession = this._register(( new Emitter()));
         this.onDidBackgroundSession = this._onDidBackgroundSession.event;
+        this._onDidChangeFocusedWidget = this._register(( new Emitter()));
+        this.onDidChangeFocusedWidget = this._onDidChangeFocusedWidget.event;
+        this._onDidChangeFocusedSession = this._register(( new Emitter()));
+        this.onDidChangeFocusedSession = this._onDidChangeFocusedSession.event;
     }
     get lastFocusedWidget() {
         return this._lastFocusedWidget;
@@ -89,7 +93,7 @@ let ChatWidgetService = class ChatWidgetService extends Disposable {
         } else {
             await this.prepareSessionForMove(sessionResource, target);
         }
-        if (target === ChatViewPaneTarget) {
+        if (target === ChatViewPaneTarget || typeof target === "undefined") {
             const chatView = await this.viewsService.openView(ChatViewId, !options?.preserveFocus);
             if (chatView) {
                 await chatView.loadSession(sessionResource);
@@ -180,6 +184,8 @@ let ChatWidgetService = class ChatWidgetService extends Disposable {
             return;
         }
         this._lastFocusedWidget = widget;
+        this._onDidChangeFocusedWidget.fire(widget);
+        this._onDidChangeFocusedSession.fire();
     }
     register(newWidget) {
         if (( this._widgets.some(widget => widget === newWidget))) {
@@ -198,6 +204,9 @@ let ChatWidgetService = class ChatWidgetService extends Disposable {
                     currentSessionResource
                 }
             ) => {
+                if (this._lastFocusedWidget === newWidget && !isEqual(previousSessionResource, currentSessionResource)) {
+                    this._onDidChangeFocusedSession.fire();
+                }
                 if (!previousSessionResource || (currentSessionResource && isEqual(previousSessionResource, currentSessionResource))) {
                     return;
                 }

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/chatQueuePickerActionItem.d.ts

@@ -24,8 +24,10 @@ export declare class ChatQueuePickerActionItem extends BaseActionViewItem {
     private readonly _primaryActionAction;
     private readonly _primaryAction;
     private readonly _dropdown;
+    private _altKeyPressed;
     constructor(action: IAction, _options: IActionViewItemOptions, commandService: ICommandService, configurationService: IConfigurationService, actionWidgetService: IActionWidgetService, keybindingService: IKeybindingService, contextKeyService: IContextKeyService, telemetryService: ITelemetryService);
     private _isSteerDefault;
+    private _isEffectiveSteer;
     private _updatePrimaryAction;
     private _runDefaultAction;
     render(container: HTMLElement): void;

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/chatQueuePickerActionItem.js

@@ -1,6 +1,6 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { $, append, addDisposableListener, EventType } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { ModifierKeyEmitter, $, append, addDisposableListener, EventType } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
 import { StandardKeyboardEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/keyboardEvent';
 import { BaseActionViewItem, ActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
 import { Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
@@ -37,8 +37,9 @@ let ChatQueuePickerActionItem = class ChatQueuePickerActionItem extends BaseActi
         super(undefined, action);
         this.commandService = commandService;
         this.configurationService = configurationService;
+        this._altKeyPressed = false;
         const isSteerDefault = this._isSteerDefault();
-        this._primaryActionAction = this._register(( new Action("chat.queuePickerPrimary", isSteerDefault ? ( localize(6168, "Steer with Message")) : ( localize(6169, "Add to Queue")), ThemeIcon.asClassName(Codicon.send), !!contextKeyService.getContextKeyValue(ChatContextKeys.inputHasText.key), () => this._runDefaultAction())));
+        this._primaryActionAction = this._register(( new Action("chat.queuePickerPrimary", isSteerDefault ? ( localize(6805, "Steer with Message")) : ( localize(6806, "Add to Queue")), ThemeIcon.asClassName(isSteerDefault ? Codicon.arrowUp : Codicon.add), !!contextKeyService.getContextKeyValue(ChatContextKeys.inputHasText.key), () => this._runDefaultAction())));
         this._primaryAction = this._register(( new ActionViewItem(undefined, this._primaryActionAction, {
             icon: true,
             label: false
@@ -46,7 +47,7 @@ let ChatQueuePickerActionItem = class ChatQueuePickerActionItem extends BaseActi
         this._register(contextKeyService.onDidChangeContext(e => {
             this._primaryActionAction.enabled = !!contextKeyService.getContextKeyValue(ChatContextKeys.inputHasText.key);
         }));
-        const dropdownAction = this._register(( new Action("chat.queuePickerDropdown", ( localize(6170, "More Actions...")))));
+        const dropdownAction = this._register(( new Action("chat.queuePickerDropdown", ( localize(6807, "More Actions...")))));
         this._dropdown = this._register(( new ChevronActionWidgetDropdown(dropdownAction, {
             actionProvider: {
                 getActions: () => this._getDropdownActions()
@@ -58,16 +59,27 @@ let ChatQueuePickerActionItem = class ChatQueuePickerActionItem extends BaseActi
                 this._updatePrimaryAction();
             }
         }));
+        this._register(ModifierKeyEmitter.getInstance().event(status => {
+            if (this._altKeyPressed !== status.altKey) {
+                this._altKeyPressed = status.altKey;
+                this._updatePrimaryAction();
+            }
+        }));
     }
     _isSteerDefault() {
         return this.configurationService.getValue(ChatConfiguration.RequestQueueingDefaultAction) === "steer";
     }
-    _updatePrimaryAction() {
+    _isEffectiveSteer() {
         const isSteerDefault = this._isSteerDefault();
-        this._primaryActionAction.label = isSteerDefault ? ( localize(6168, "Steer with Message")) : ( localize(6169, "Add to Queue"));
+        return this._altKeyPressed ? !isSteerDefault : isSteerDefault;
+    }
+    _updatePrimaryAction() {
+        const isSteer = this._isEffectiveSteer();
+        this._primaryActionAction.label = isSteer ? ( localize(6805, "Steer with Message")) : ( localize(6806, "Add to Queue"));
+        this._primaryActionAction.class = ThemeIcon.asClassName(isSteer ? Codicon.arrowUp : Codicon.add);
     }
     _runDefaultAction() {
-        const actionId = this._isSteerDefault() ? ChatSteerWithMessageAction.ID : ChatQueueMessageAction.ID;
+        const actionId = this._isEffectiveSteer() ? ChatSteerWithMessageAction.ID : ChatQueueMessageAction.ID;
         this.commandService.executeCommand(actionId);
     }
     render(container) {
@@ -110,16 +122,18 @@ let ChatQueuePickerActionItem = class ChatQueuePickerActionItem extends BaseActi
         this._dropdown.setFocusable(focusable);
     }
     _getDropdownActions() {
+        const isSteerDefault = this._isSteerDefault();
         const queueAction = {
             id: ChatQueueMessageAction.ID,
-            label: ( localize(6169, "Add to Queue")),
+            label: ( localize(6806, "Add to Queue")),
             tooltip: "",
             enabled: true,
+            checked: !isSteerDefault,
             icon: Codicon.add,
             class: undefined,
             hover: {
                 content: ( localize(
-                    6171,
+                    6808,
                     "Queue this message to send after the current request completes. The current response will finish uninterrupted before the queued message is sent."
                 ))
             },
@@ -129,14 +143,15 @@ let ChatQueuePickerActionItem = class ChatQueuePickerActionItem extends BaseActi
         };
         const steerAction = {
             id: ChatSteerWithMessageAction.ID,
-            label: ( localize(6168, "Steer with Message")),
+            label: ( localize(6805, "Steer with Message")),
             tooltip: "",
             enabled: true,
-            icon: Codicon.arrowRight,
+            checked: isSteerDefault,
+            icon: Codicon.arrowUp,
             class: undefined,
             hover: {
                 content: ( localize(
-                    6172,
+                    6809,
                     "Send this message at the next opportunity, signaling the current request to yield. The current response will stop and the new message will be sent immediately."
                 ))
             },
@@ -146,13 +161,13 @@ let ChatQueuePickerActionItem = class ChatQueuePickerActionItem extends BaseActi
         };
         const sendAction = {
             id: "_" + ChatSubmitAction.ID,
-            label: ( localize(6173, "Stop and Send")),
+            label: ( localize(6810, "Stop and Send")),
             tooltip: "",
             enabled: true,
-            icon: Codicon.send,
+            icon: Codicon.arrowRight,
             class: undefined,
             hover: {
-                content: ( localize(6174, "Cancel the current request and send this message immediately."))
+                content: ( localize(6811, "Cancel the current request and send this message immediately."))
             },
             run: () => {
                 this.commandService.executeCommand(ChatSubmitAction.ID);

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/chatStatusWidget.js

@@ -41,8 +41,7 @@ let ChatStatusWidget = class ChatStatusWidget extends Disposable {
     initializeIfEnabled() {
         const entitlement = this.chatEntitlementService.entitlement;
         const isAnonymous = this.chatEntitlementService.anonymous;
-        const enabledSku = this.configurationService.getValue("chat.statusWidget.sku");
-        if (isAnonymous && enabledSku === "anonymous") {
+        if (isAnonymous && this.configurationService.getValue("chat.statusWidget.anonymous")) {
             this.createWidgetContent("anonymous");
         } else if (entitlement === ChatEntitlement.Free) {
             this.createWidgetContent("free");
@@ -66,19 +65,19 @@ let ChatStatusWidget = class ChatStatusWidget extends Disposable {
         this.actionButton.element.classList.add("chat-status-button");
         if (enabledSku === "anonymous") {
             const message = ( localize(
-                6175,
-                "You've reached the limit for chat messages. Try Copilot Pro for free."
+                6812,
+                "You've reached the limit for chat messages. Sign in to use Copilot Free."
             ));
-            const buttonLabel = ( localize(6176, "Sign In"));
+            const buttonLabel = ( localize(6813, "Sign In"));
             this.messageElement.textContent = message;
             this.actionButton.label = buttonLabel;
-            this.actionButton.element.ariaLabel = ( localize(6177, "{0} {1}", message, buttonLabel));
+            this.actionButton.element.ariaLabel = ( localize(6814, "{0} {1}", message, buttonLabel));
         } else {
-            const message = ( localize(6178, "You've reached the limit for chat messages."));
-            const buttonLabel = ( localize(6179, "Upgrade"));
+            const message = ( localize(6815, "You've reached the limit for chat messages."));
+            const buttonLabel = ( localize(6816, "Upgrade"));
             this.messageElement.textContent = message;
             this.actionButton.label = buttonLabel;
-            this.actionButton.element.ariaLabel = ( localize(6180, "{0} {1}", message, buttonLabel));
+            this.actionButton.element.ariaLabel = ( localize(6817, "{0} {1}", message, buttonLabel));
         }
         this._register(this.actionButton.onDidClick(async () => {
             const commandId = this.chatEntitlementService.anonymous ? CHAT_SETUP_ACTION_ID : "workbench.action.chat.upgradePlan";