@codingame/monaco-vscode-chat-service-override 31.0.1 → 32.0.0

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

@@ -3,19 +3,15 @@ import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/comm
 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';
+import { WorkingDirectory } from '../../common/workingDirectory.js';
 
-function resolveToolUri(input, workspaceContextService) {
+function resolveToolUri(input, workspaceContextService, workingDirectory) {
     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);
-        }
+        const workingDir = ( new WorkingDirectory(workspaceContextService, workingDirectory));
+        return workingDir.resolveRelativePath(input.filePath);
     }
     return undefined;
 }

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

@@ -0,0 +1,18 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IToolResult } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+import { IToolResultFilter } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/toolResultCompressor";
+import { IToolResultCompressor } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/toolResultCompressor.service";
+export declare class ToolResultCompressorService extends Disposable implements IToolResultCompressor {
+    private readonly _configurationService;
+    private readonly _telemetryService;
+    private readonly _logService;
+    readonly _serviceBrand: undefined;
+    private readonly _filters;
+    constructor(_configurationService: IConfigurationService, _telemetryService: ITelemetryService, _logService: ILogService);
+    registerFilter(filter: IToolResultFilter): void;
+    maybeCompress(toolId: string, input: unknown, result: IToolResult): IToolResult | undefined;
+    private _sendTelemetry;
+}

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

@@ -0,0 +1,56 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+
+let ToolResultCompressorService = class ToolResultCompressorService extends Disposable {
+    constructor(_configurationService, _telemetryService, _logService) {
+        super();
+        this._configurationService = _configurationService;
+        this._telemetryService = _telemetryService;
+        this._logService = _logService;
+        this._filters = ( new Map());
+    }
+    registerFilter(filter) {
+        for (const id of filter.toolIds) {
+            let bucket = this._filters.get(id);
+            if (!bucket) {
+                bucket = [];
+                this._filters.set(id, bucket);
+            }
+            bucket.push(filter);
+        }
+    }
+    maybeCompress(toolId, input, result) {
+        if (!this._configurationService.getValue(ChatConfiguration.CompressOutputEnabled)) {
+            return undefined;
+        }
+        const filters = this._filters.get(toolId);
+        if (!filters || filters.length === 0) {
+            return undefined;
+        }
+        const matchingFilters = filters.filter(f => f.matches(toolId, input));
+        if (matchingFilters.length === 0) {
+            return undefined;
+        }
+        matchingFilters.slice();
+        {
+            return undefined;
+        }
+    }
+    _sendTelemetry(toolId, filterIds, beforeChars, afterChars) {
+        this._telemetryService.publicLog2("toolResultCompressed", {
+            toolId,
+            filters: filterIds.join(","),
+            beforeChars,
+            afterChars
+        });
+    }
+};
+ToolResultCompressorService = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, ITelemetryService)), ( __param(2, ILogService))], ToolResultCompressorService));
+
+export { ToolResultCompressorService };

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

@@ -1,10 +1,8 @@
 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 { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.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";
@@ -14,15 +12,13 @@ import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/
 export declare const UsagesToolId = "vscode_listCodeUsages";
 export declare class UsagesTool extends Disposable implements IToolImpl {
     private readonly _languageFeaturesService;
-    private readonly _languageService;
     private readonly _modelService;
     private readonly _searchService;
     private readonly _textModelService;
     private readonly _workspaceContextService;
-    private readonly _onDidUpdateToolData;
-    readonly onDidUpdateToolData: Event<void>;
-    constructor(_languageFeaturesService: ILanguageFeaturesService, _languageService: ILanguageService, _modelService: IModelService, _searchService: ISearchService, _textModelService: ITextModelService, _workspaceContextService: IWorkspaceContextService);
-    getToolData(): IToolData | undefined;
+    constructor(_languageFeaturesService: ILanguageFeaturesService, _modelService: IModelService, _searchService: ISearchService, _textModelService: ITextModelService, _workspaceContextService: IWorkspaceContextService);
+    getToolData(): IToolData;
+    private _buildToolData;
     prepareToolInvocation(context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
     invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
     private _getLinePreviews;

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

@@ -1,7 +1,6 @@
 
 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';
@@ -13,7 +12,6 @@ import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core
 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 { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.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';
@@ -38,10 +36,12 @@ Input:
 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.`;
+const StaticModelDescription = BaseModelDescription + `
+
+If the file's language has no reference provider registered, the tool returns an error.`;
 let UsagesTool = class UsagesTool extends Disposable {
     constructor(
         _languageFeaturesService,
-        _languageService,
         _modelService,
         _searchService,
         _textModelService,
@@ -49,45 +49,21 @@ let UsagesTool = class UsagesTool extends Disposable {
     ) {
         super();
         this._languageFeaturesService = _languageFeaturesService;
-        this._languageService = _languageService;
         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;
-        if (languageIds.size === 0) {
-            return undefined;
-        }
-        let modelDescription = BaseModelDescription;
-        let userDescription;
-        if (( languageIds.has("*"))) {
-            modelDescription += "\n\nSupported for all languages.";
-            userDescription = ( localize(6779, "Find references, definitions, and implementations of a symbol"));
-        } else {
-            const sorted = [...languageIds].sort();
-            modelDescription += `\n\nCurrently supported for: ${sorted.join(", ")}.`;
-            const niceNames = ( sorted.map(id => this._languageService.getLanguageName(id) ?? id));
-            userDescription = ( localize(
-                6780,
-                "Find references, definitions, and implementations of a symbol ({0})",
-                niceNames.join(", ")
-            ));
-        }
+        return this._buildToolData(StaticModelDescription, ( localize(7026, "Find references, definitions, and implementations of a symbol")));
+    }
+    _buildToolData(modelDescription, userDescription) {
         return {
             id: UsagesToolId,
             toolReferenceName: "usages",
             canBeReferencedInPrompt: false,
             icon: ThemeIcon.fromId(Codicon.references.id),
-            displayName: ( localize(6781, "List Code Usages")),
+            displayName: ( localize(7027, "List Code Usages")),
             userDescription,
             modelDescription,
             source: ToolDataSource.Internal,
@@ -119,12 +95,12 @@ let UsagesTool = class UsagesTool extends Disposable {
     async prepareToolInvocation(context, _token) {
         const input = context.parameters;
         return {
-            invocationMessage: ( localize(6782, "Analyzing usages of `{0}`", input.symbol))
+            invocationMessage: ( localize(7028, "Analyzing usages of `{0}`", input.symbol))
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {
         const input = invocation.parameters;
-        const uri = resolveToolUri(input, this._workspaceContextService);
+        const uri = resolveToolUri(input, this._workspaceContextService, invocation.context?.workingDirectory);
         if (!uri) {
             return errorResult(
                 "Provide either \"uri\" (a full URI) or \"filePath\" (a workspace-relative path) to identify the file."
@@ -172,7 +148,7 @@ let UsagesTool = class UsagesTool extends Disposable {
             )]);
             if (references.length === 0) {
                 const result = createToolSimpleTextResult(`No usages found for \`${input.symbol}\`.`);
-                result.toolResultMessage = ( new MarkdownString(( localize(6783, "Analyzed usages of `{0}`, no results", input.symbol))));
+                result.toolResultMessage = ( new MarkdownString(( localize(7029, "Analyzed usages of `{0}`, no results", input.symbol))));
                 return result;
             }
             const previews = await this._getLinePreviews(input.symbol, references, token);
@@ -193,8 +169,8 @@ let UsagesTool = class UsagesTool extends Disposable {
             }
             const text = lines.join("\n");
             const result = createToolSimpleTextResult(text);
-            result.toolResultMessage = references.length === 1 ? ( new MarkdownString(( localize(6784, "Analyzed usages of `{0}`, 1 result", input.symbol)))) : ( new MarkdownString(( localize(
-                6785,
+            result.toolResultMessage = references.length === 1 ? ( new MarkdownString(( localize(7030, "Analyzed usages of `{0}`, 1 result", input.symbol)))) : ( new MarkdownString(( localize(
+                7031,
                 "Analyzed usages of `{0}`, {1} results",
                 input.symbol,
                 references.length
@@ -296,7 +272,7 @@ let UsagesTool = class UsagesTool extends Disposable {
         return Range.areIntersectingOrTouching(a.range, b.range);
     }
 };
-UsagesTool = ( __decorate([( __param(0, ILanguageFeaturesService)), ( __param(1, ILanguageService)), ( __param(2, IModelService)), ( __param(3, ISearchService)), ( __param(4, ITextModelService)), ( __param(5, IWorkspaceContextService))], UsagesTool));
+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";
@@ -304,21 +280,7 @@ let UsagesToolContribution = class UsagesToolContribution extends Disposable {
     constructor(toolsService, instantiationService) {
         super();
         const usagesTool = this._store.add(instantiationService.createInstance(UsagesTool));
-        let registration;
-        const registerUsagesTool = () => {
-            registration?.dispose();
-            registration = undefined;
-            toolsService.flushToolUpdates();
-            const toolData = usagesTool.getToolData();
-            if (toolData) {
-                registration = toolsService.registerTool(toolData, usagesTool);
-            }
-        };
-        registerUsagesTool();
-        this._store.add(usagesTool.onDidUpdateToolData(registerUsagesTool));
-        this._store.add({
-            dispose: () => registration?.dispose()
-        });
+        this._store.add(toolsService.registerTool(usagesTool.getToolData(), usagesTool));
     }
 };
 UsagesToolContribution = ( __decorate([( __param(0, ILanguageModelToolsService)), ( __param(1, IInstantiationService))], UsagesToolContribution));

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

@@ -17,29 +17,29 @@ const chatViewsWelcomeJsonSchema = {
     properties: {
         icon: {
             type: "string",
-            description: ( localize(6786, "The icon for the welcome message."))
+            description: ( localize(7032, "The icon for the welcome message."))
         },
         title: {
             type: "string",
-            description: ( localize(6787, "The title of the welcome message."))
+            description: ( localize(7033, "The title of the welcome message."))
         },
         content: {
             type: "string",
             description: ( localize(
-                6788,
+                7034,
                 "The content of the welcome message. The first command link will be rendered as a button."
             ))
         },
         when: {
             type: "string",
-            description: ( localize(6789, "Condition when the welcome message is shown."))
+            description: ( localize(7035, "Condition when the welcome message is shown."))
         }
     }
 };
 const chatViewsWelcomeExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: "chatViewsWelcome",
     jsonSchema: {
-        description: ( localize(6790, "Contributes a welcome message to a chat view")),
+        description: ( localize(7036, "Contributes a welcome message to a chat view")),
         type: "array",
         items: chatViewsWelcomeJsonSchema
     }

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

@@ -2,6 +2,7 @@ import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event"
 import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { ILayoutService } from "@codingame/monaco-vscode-api/vscode/vs/platform/layout/browser/layoutService.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { type PreferredGroup } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService";
 import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
 import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
@@ -19,6 +20,7 @@ export declare class ChatWidgetService extends Disposable implements IChatWidget
     private readonly layoutService;
     private readonly editorService;
     private readonly chatService;
+    private readonly logService;
     readonly _serviceBrand: undefined;
     private _widgets;
     private _lastFocusedWidget;
@@ -30,7 +32,7 @@ export declare class ChatWidgetService extends Disposable implements IChatWidget
     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);
+    constructor(editorGroupsService: IEditorGroupsService, viewsService: IViewsService, quickChatService: IQuickChatService, layoutService: ILayoutService, editorService: IEditorService, chatService: IChatService, logService: ILogService);
     get lastFocusedWidget(): IChatWidget | undefined;
     getAllWidgets(): ReadonlyArray<IChatWidget>;
     getWidgetsByLocations(location: ChatAgentLocation): ReadonlyArray<IChatWidget>;

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

@@ -6,6 +6,7 @@ import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/comm
 import { Disposable, combinedDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { ILayoutService } from '@codingame/monaco-vscode-api/vscode/vs/platform/layout/browser/layoutService.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { ACTIVE_GROUP } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService';
 import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
 import { isEditorGroup } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService';
@@ -24,7 +25,8 @@ let ChatWidgetService = class ChatWidgetService extends Disposable {
         quickChatService,
         layoutService,
         editorService,
-        chatService
+        chatService,
+        logService
     ) {
         super();
         this.editorGroupsService = editorGroupsService;
@@ -33,6 +35,7 @@ let ChatWidgetService = class ChatWidgetService extends Disposable {
         this.layoutService = layoutService;
         this.editorService = editorService;
         this.chatService = chatService;
+        this.logService = logService;
         this._widgets = [];
         this._lastFocusedWidget = undefined;
         this._onDidAddWidget = this._register(( new Emitter()));
@@ -85,9 +88,15 @@ let ChatWidgetService = class ChatWidgetService extends Disposable {
         return false;
     }
     async openSession(sessionResource, target, options) {
+        const t0 = Date.now();
+        const targetKind = target === ChatViewPaneTarget ? "view" : (typeof target === "undefined" ? "undefined" : "editor");
+        this.logService.trace(`[ChatWidgetService] openSession start uri=${( sessionResource.toString())} target=${targetKind}`);
         if (typeof target === "undefined" || options?.revealIfOpened) {
             const alreadyOpenWidget = await this.revealSessionIfAlreadyOpen(sessionResource, options);
             if (alreadyOpenWidget) {
+                this.logService.trace(
+                    `[ChatWidgetService] openSession done total=${Date.now() - t0}ms uri=${( sessionResource.toString())} path=reveal`
+                );
                 return alreadyOpenWidget;
             }
         } else {
@@ -101,6 +110,9 @@ let ChatWidgetService = class ChatWidgetService extends Disposable {
                     chatView.focusInput();
                 }
             }
+            this.logService.trace(
+                `[ChatWidgetService] openSession done total=${Date.now() - t0}ms uri=${( sessionResource.toString())} path=view`
+            );
             return chatView?.widget;
         }
         const pane = await this.editorService.openEditor({
@@ -110,6 +122,9 @@ let ChatWidgetService = class ChatWidgetService extends Disposable {
                 revealIfOpened: options?.revealIfOpened ?? true
             }
         }, target);
+        this.logService.trace(
+            `[ChatWidgetService] openSession done total=${Date.now() - t0}ms uri=${( sessionResource.toString())} path=editor`
+        );
         return pane instanceof ChatEditor ? pane.widget : undefined;
     }
     async revealSessionIfAlreadyOpen(sessionResource, options) {
@@ -225,6 +240,6 @@ let ChatWidgetService = class ChatWidgetService extends Disposable {
         );
     }
 };
-ChatWidgetService = ( __decorate([( __param(0, IEditorGroupsService)), ( __param(1, IViewsService)), ( __param(2, IQuickChatService)), ( __param(3, ILayoutService)), ( __param(4, IEditorService)), ( __param(5, IChatService))], ChatWidgetService));
+ChatWidgetService = ( __decorate([( __param(0, IEditorGroupsService)), ( __param(1, IViewsService)), ( __param(2, IQuickChatService)), ( __param(3, ILayoutService)), ( __param(4, IEditorService)), ( __param(5, IChatService)), ( __param(6, ILogService))], ChatWidgetService));
 
 export { ChatWidgetService };

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

@@ -21,6 +21,8 @@ import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/w
 export declare class ChatQueuePickerActionItem extends BaseActionViewItem {
     private readonly commandService;
     private readonly configurationService;
+    private readonly keybindingService;
+    private readonly contextKeyService;
     private readonly _primaryActionAction;
     private readonly _primaryAction;
     private readonly _dropdown;

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

@@ -37,23 +37,25 @@ let ChatQueuePickerActionItem = class ChatQueuePickerActionItem extends BaseActi
         super(undefined, action);
         this.commandService = commandService;
         this.configurationService = configurationService;
+        this.keybindingService = keybindingService;
+        this.contextKeyService = contextKeyService;
         this._altKeyPressed = false;
         const isSteerDefault = this._isSteerDefault();
-        this._primaryActionAction = this._register(( new Action("chat.queuePickerPrimary", isSteerDefault ? ( localize(7184, "Steer with Message")) : ( localize(7185, "Add to Queue")), ThemeIcon.asClassName(isSteerDefault ? Codicon.arrowUp : Codicon.add), !!contextKeyService.getContextKeyValue(ChatContextKeys.inputHasText.key), () => this._runDefaultAction())));
+        this._primaryActionAction = this._register(( new Action("chat.queuePickerPrimary", isSteerDefault ? ( localize(7495, "Steer with Message")) : ( localize(7496, "Add to Queue")), ThemeIcon.asClassName(isSteerDefault ? Codicon.arrowUp : Codicon.add), !!this.contextKeyService.getContextKeyValue(ChatContextKeys.inputHasText.key), () => this._runDefaultAction())));
         this._primaryAction = this._register(( new ActionViewItem(undefined, this._primaryActionAction, {
             icon: true,
             label: false
         })));
-        this._register(contextKeyService.onDidChangeContext(e => {
-            this._primaryActionAction.enabled = !!contextKeyService.getContextKeyValue(ChatContextKeys.inputHasText.key);
+        this._register(this.contextKeyService.onDidChangeContext(e => {
+            this._primaryActionAction.enabled = !!this.contextKeyService.getContextKeyValue(ChatContextKeys.inputHasText.key);
         }));
-        const dropdownAction = this._register(( new Action("chat.queuePickerDropdown", ( localize(7186, "More Actions...")))));
+        const dropdownAction = this._register(( new Action("chat.queuePickerDropdown", ( localize(7497, "More Actions...")))));
         this._dropdown = this._register(( new ChevronActionWidgetDropdown(dropdownAction, {
             actionProvider: {
                 getActions: () => this._getDropdownActions()
             },
             showItemKeybindings: true
-        }, actionWidgetService, keybindingService, contextKeyService, telemetryService)));
+        }, actionWidgetService, this.keybindingService, this.contextKeyService, telemetryService)));
         this._register(this.configurationService.onDidChangeConfiguration(e => {
             if (e.affectsConfiguration(ChatConfiguration.RequestQueueingDefaultAction)) {
                 this._updatePrimaryAction();
@@ -75,7 +77,7 @@ let ChatQueuePickerActionItem = class ChatQueuePickerActionItem extends BaseActi
     }
     _updatePrimaryAction() {
         const isSteer = this._isEffectiveSteer();
-        this._primaryActionAction.label = isSteer ? ( localize(7184, "Steer with Message")) : ( localize(7185, "Add to Queue"));
+        this._primaryActionAction.label = isSteer ? ( localize(7495, "Steer with Message")) : ( localize(7496, "Add to Queue"));
         this._primaryActionAction.class = ThemeIcon.asClassName(isSteer ? Codicon.arrowUp : Codicon.add);
     }
     _runDefaultAction() {
@@ -123,17 +125,25 @@ let ChatQueuePickerActionItem = class ChatQueuePickerActionItem extends BaseActi
     }
     _getDropdownActions() {
         const isSteerDefault = this._isSteerDefault();
+        const lookupContext = this.contextKeyService.createOverlay([
+            [ChatContextKeys.inputHasText.key, true],
+            [ChatContextKeys.inChatInput.key, true],
+            [ChatContextKeys.requestInProgress.key, true]
+        ]);
+        const queueKeybinding = this.keybindingService.lookupKeybinding(ChatQueueMessageAction.ID, lookupContext, true);
+        const steerKeybinding = this.keybindingService.lookupKeybinding(ChatSteerWithMessageAction.ID, lookupContext, true);
         const queueAction = {
             id: ChatQueueMessageAction.ID,
-            label: ( localize(7185, "Add to Queue")),
+            label: ( localize(7496, "Add to Queue")),
             tooltip: "",
             enabled: true,
             checked: !isSteerDefault,
             icon: Codicon.add,
             class: undefined,
+            keybinding: queueKeybinding,
             hover: {
                 content: ( localize(
-                    7187,
+                    7498,
                     "Queue this message to send after the current request completes. The current response will finish uninterrupted before the queued message is sent."
                 ))
             },
@@ -143,15 +153,16 @@ let ChatQueuePickerActionItem = class ChatQueuePickerActionItem extends BaseActi
         };
         const steerAction = {
             id: ChatSteerWithMessageAction.ID,
-            label: ( localize(7184, "Steer with Message")),
+            label: ( localize(7495, "Steer with Message")),
             tooltip: "",
             enabled: true,
             checked: isSteerDefault,
             icon: Codicon.arrowUp,
             class: undefined,
+            keybinding: steerKeybinding,
             hover: {
                 content: ( localize(
-                    7188,
+                    7499,
                     "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."
                 ))
             },
@@ -161,13 +172,13 @@ let ChatQueuePickerActionItem = class ChatQueuePickerActionItem extends BaseActi
         };
         const sendAction = {
             id: "_" + ChatSubmitAction.ID,
-            label: ( localize(7189, "Stop and Send")),
+            label: ( localize(7500, "Stop and Send")),
             tooltip: "",
             enabled: true,
             icon: Codicon.arrowRight,
             class: undefined,
             hover: {
-                content: ( localize(7190, "Cancel the current request and send this message immediately."))
+                content: ( localize(7501, "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/editor/agentHostInputCompletions.d.ts

@@ -0,0 +1,39 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { Position } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position";
+import { CompletionItem } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { ILanguageFeaturesService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service";
+import { IChatInputCompletionItem } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+import { IChatWidget } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { AgentHostInputCompletionsBase } from "./agentHostInputCompletionsBase.js";
+/**
+ * Completion provider that delegates `@`-mention (and other server-defined)
+ * completions to the agent host for AHP-backed chat sessions.
+ *
+ * Registrations are made dynamically per content-provider scheme so each
+ * connection can announce its own trigger characters via the protocol's
+ * `InitializeResult.completionTriggerCharacters`. When a content provider
+ * is registered, we ask it for its trigger chars and register a Monaco
+ * completion provider scoped to that scheme; when it is unregistered we
+ * tear the registration down.
+ *
+ * The provider uses the same `_addReferenceCmd` pattern as
+ * `BuiltinDynamicCompletions`: when an item is accepted, a command runs
+ * that adds an {@link IDynamicVariable} entry to the widget's variable
+ * model so the resource becomes part of the outgoing user message.
+ */
+export declare class AgentHostInputCompletions extends AgentHostInputCompletionsBase<IChatWidget, string> {
+    private readonly _chatWidgetService;
+    private static readonly addReferenceCommand;
+    /** Per-scheme registrations of the Monaco completion provider. */
+    private readonly _registrations;
+    constructor(languageFeaturesService: ILanguageFeaturesService, _chatWidgetService: IChatWidgetService, chatSessionsService: IChatSessionsService);
+    private _registerForScheme;
+    protected _resolveContext(model: ITextModel, scheme: string): {
+        sessionResource: URI;
+        context: IChatWidget;
+    } | undefined;
+    protected _buildItem(position: Position, item: IChatInputCompletionItem, widget: IChatWidget): CompletionItem;
+}