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

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

@@ -0,0 +1,45 @@
+
+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 { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { createToolSimpleTextResult } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/builtinTools/toolHelpers';
+
+function resolveToolUri(input, workspaceContextService) {
+    if (input.uri) {
+        return ( URI.parse(input.uri));
+    }
+    if (input.filePath) {
+        const folders = workspaceContextService.getWorkspace().folders;
+        if (folders.length === 1) {
+            return folders[0].toResource(input.filePath);
+        }
+        for (const folder of folders) {
+            return folder.toResource(input.filePath);
+        }
+    }
+    return undefined;
+}
+function findLineNumber(model, lineContent) {
+    const parts = lineContent.trim().split(/\s+/);
+    const pattern = ( parts.map(escapeRegExpCharacters)).join("\\s+");
+    const matches = model.findMatches(pattern, false, true, false, null, false, 1);
+    if (matches.length === 0) {
+        return undefined;
+    }
+    return matches[0].range.startLineNumber;
+}
+function findSymbolColumn(lineText, symbol) {
+    const pattern = ( new RegExp(`\\b${escapeRegExpCharacters(symbol)}\\b`));
+    const match = pattern.exec(lineText);
+    if (match) {
+        return match.index + 1;
+    }
+    return undefined;
+}
+function errorResult(message) {
+    const result = createToolSimpleTextResult(message);
+    result.toolResultMessage = ( new MarkdownString(message));
+    return result;
+}
+
+export { errorResult, findLineNumber, findSymbolColumn, resolveToolUri };

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

@@ -44,7 +44,7 @@ const toolSetsSchema = {
     allowComments: true,
     allowTrailingCommas: true,
     defaultSnippets: [{
-        label: ( localize(5872, "Empty tool set")),
+        label: ( localize(6370, "Empty tool set")),
         body: {
             "${1:toolSetName}": {
                 "tools": ["${2:someTool}", "${3:anotherTool}"],
@@ -54,7 +54,7 @@ const toolSetsSchema = {
         }
     }],
     type: "object",
-    description: ( localize(5873, "User tool sets configuration")),
+    description: ( localize(6371, "User tool sets configuration")),
     additionalProperties: {
         type: "object",
         required: ["tools"],
@@ -62,7 +62,7 @@ const toolSetsSchema = {
         properties: {
             tools: {
                 description: ( localize(
-                    5874,
+                    6372,
                     "A list of tools or tool sets to include in this tool set. Cannot be empty and must reference tools the way they are referenced in prompts."
                 )),
                 type: "array",
@@ -75,7 +75,7 @@ const toolSetsSchema = {
             },
             icon: {
                 description: ( localize(
-                    5875,
+                    6373,
                     "Icon to use for this tool set in the UI. Uses the \"\\$(name)\"-syntax, like \"\\$(zap)\""
                 )),
                 type: "string",
@@ -83,7 +83,7 @@ const toolSetsSchema = {
                 markdownEnumDescriptions: Array.from(getAllCodicons(), icon => `$(${icon.id})`)
             },
             description: {
-                description: ( localize(5876, "A short description of this tool set.")),
+                description: ( localize(6374, "A short description of this tool set.")),
                 type: "string"
             }
         }
@@ -184,7 +184,7 @@ let UserToolSetsContributions = class UserToolSetsContributions extends Disposab
             });
             for (const item of data) {
                 toolEnumValues.push(item.name);
-                toolEnumDescriptions.push(( localize(5877, "{1} ({0})\n\n{2}", item.sourceLabel, item.name, item.description)));
+                toolEnumDescriptions.push(( localize(6375, "{1} ({0})\n\n{2}", item.sourceLabel, item.name, item.description)));
             }
             store.clear();
             reg.registerSchema(toolSetSchemaId, toolSetsSchema, store);
@@ -281,8 +281,8 @@ class ConfigureToolSets extends Action2 {
     constructor() {
         super({
             id: ConfigureToolSets.ID,
-            title: ( localize2(5878, "Configure Tool Sets...")),
-            shortTitle: ( localize(5879, "Tool Sets")),
+            title: ( localize2(6376, "Configure Tool Sets...")),
+            shortTitle: ( localize(6377, "Tool Sets")),
             category: CHAT_CATEGORY,
             f1: true,
             precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ChatContextKeys.Tools.toolsCount.greater(0))),
@@ -303,7 +303,7 @@ class ConfigureToolSets extends Action2 {
         const textFileService = accessor.get(ITextFileService);
         const picks = [];
         picks.push({
-            label: ( localize(5880, "Create new tool sets file...")),
+            label: ( localize(6378, "Create new tool sets file...")),
             alwaysShow: true,
             iconClass: ThemeIcon.asClassName(Codicon.plus)
         });
@@ -320,7 +320,7 @@ class ConfigureToolSets extends Action2 {
         }
         const pick = await quickInputService.pick(picks, {
             canPickMany: false,
-            placeHolder: ( localize(5881, "Select a tool set to configure"))
+            placeHolder: ( localize(6379, "Select a tool set to configure"))
         });
         if (!pick) {
             return;
@@ -328,13 +328,13 @@ class ConfigureToolSets extends Action2 {
         let resource;
         if (!pick.toolset) {
             const name = await quickInputService.input({
-                placeHolder: ( localize(5882, "Type tool sets file name")),
+                placeHolder: ( localize(6380, "Type tool sets file name")),
                 validateInput: async input => {
                     if (!input) {
-                        return localize(5883, "Invalid file name");
+                        return localize(6381, "Invalid file name");
                     }
                     if (!isValidBasename(input)) {
-                        return localize(5884, "'{0}' is not a valid file name", input);
+                        return localize(6382, "'{0}' is not a valid file name", input);
                     }
                     return undefined;
                 }

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

@@ -0,0 +1,33 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+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 { 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 { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { ISearchService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/search.service";
+import { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress } 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";
+export declare const UsagesToolId = "vscode_listCodeUsages";
+export declare class UsagesTool extends Disposable implements IToolImpl {
+    private readonly _languageFeaturesService;
+    private readonly _modelService;
+    private readonly _searchService;
+    private readonly _textModelService;
+    private readonly _workspaceContextService;
+    private readonly _onDidUpdateToolData;
+    readonly onDidUpdateToolData: Event<void>;
+    constructor(_languageFeaturesService: ILanguageFeaturesService, _modelService: IModelService, _searchService: ISearchService, _textModelService: ITextModelService, _workspaceContextService: IWorkspaceContextService);
+    getToolData(): IToolData;
+    prepareToolInvocation(context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+    invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
+    private _getLinePreviews;
+    private _classifyReference;
+    private _overlaps;
+}
+export declare class UsagesToolContribution extends Disposable implements IWorkbenchContribution {
+    static readonly ID = "chat.usagesTool";
+    constructor(toolsService: ILanguageModelToolsService, instantiationService: IInstantiationService);
+}

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(6383, "List Code Usages")),
+            userDescription: ( localize(6384, "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(6385, "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(6386, "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(6387, "Analyzed usages of `{0}`, 1 result", input.symbol)))) : ( new MarkdownString(( localize(
+                6388,
+                "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(6394, "The icon for the welcome message."))
         },
         title: {
             type: "string",
-            description: ( localize(5891, "The title of the welcome message."))
+            description: ( localize(6395, "The title of the welcome message."))
         },
         content: {
             type: "string",
             description: ( localize(
-                5892,
+                6396,
                 "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(6397, "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(6398, "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.js

@@ -38,7 +38,7 @@ let ChatQueuePickerActionItem = class ChatQueuePickerActionItem extends BaseActi
         this.commandService = commandService;
         this.configurationService = configurationService;
         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(6718, "Steer with Message")) : ( localize(6719, "Add to Queue")), ThemeIcon.asClassName(Codicon.arrowUp), !!contextKeyService.getContextKeyValue(ChatContextKeys.inputHasText.key), () => this._runDefaultAction())));
         this._primaryAction = this._register(( new ActionViewItem(undefined, this._primaryActionAction, {
             icon: true,
             label: false
@@ -46,7 +46,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(6720, "More Actions...")))));
         this._dropdown = this._register(( new ChevronActionWidgetDropdown(dropdownAction, {
             actionProvider: {
                 getActions: () => this._getDropdownActions()
@@ -64,7 +64,7 @@ let ChatQueuePickerActionItem = class ChatQueuePickerActionItem extends BaseActi
     }
     _updatePrimaryAction() {
         const isSteerDefault = this._isSteerDefault();
-        this._primaryActionAction.label = isSteerDefault ? ( localize(6168, "Steer with Message")) : ( localize(6169, "Add to Queue"));
+        this._primaryActionAction.label = isSteerDefault ? ( localize(6718, "Steer with Message")) : ( localize(6719, "Add to Queue"));
     }
     _runDefaultAction() {
         const actionId = this._isSteerDefault() ? ChatSteerWithMessageAction.ID : ChatQueueMessageAction.ID;
@@ -112,14 +112,14 @@ let ChatQueuePickerActionItem = class ChatQueuePickerActionItem extends BaseActi
     _getDropdownActions() {
         const queueAction = {
             id: ChatQueueMessageAction.ID,
-            label: ( localize(6169, "Add to Queue")),
+            label: ( localize(6719, "Add to Queue")),
             tooltip: "",
             enabled: true,
             icon: Codicon.add,
             class: undefined,
             hover: {
                 content: ( localize(
-                    6171,
+                    6721,
                     "Queue this message to send after the current request completes. The current response will finish uninterrupted before the queued message is sent."
                 ))
             },
@@ -129,14 +129,14 @@ let ChatQueuePickerActionItem = class ChatQueuePickerActionItem extends BaseActi
         };
         const steerAction = {
             id: ChatSteerWithMessageAction.ID,
-            label: ( localize(6168, "Steer with Message")),
+            label: ( localize(6718, "Steer with Message")),
             tooltip: "",
             enabled: true,
             icon: Codicon.arrowRight,
             class: undefined,
             hover: {
                 content: ( localize(
-                    6172,
+                    6722,
                     "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 +146,13 @@ let ChatQueuePickerActionItem = class ChatQueuePickerActionItem extends BaseActi
         };
         const sendAction = {
             id: "_" + ChatSubmitAction.ID,
-            label: ( localize(6173, "Stop and Send")),
+            label: ( localize(6723, "Stop and Send")),
             tooltip: "",
             enabled: true,
-            icon: Codicon.send,
+            icon: Codicon.arrowUp,
             class: undefined,
             hover: {
-                content: ( localize(6174, "Cancel the current request and send this message immediately."))
+                content: ( localize(6724, "Cancel the current request and send this message immediately."))
             },
             run: () => {
                 this.commandService.executeCommand(ChatSubmitAction.ID);