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

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

@@ -0,0 +1,136 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { CompletionItemKind } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
+import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
+import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { LifecyclePhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { ChatDynamicVariableModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/attachments/chatDynamicVariables';
+import { isAgentHostTarget } 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 { getChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { AgentHostInputCompletionsBase } from './agentHostInputCompletionsBase.js';
+
+var AgentHostInputCompletions_1;
+let AgentHostInputCompletions = class AgentHostInputCompletions extends AgentHostInputCompletionsBase {
+    static {
+        AgentHostInputCompletions_1 = this;
+    }
+    static {
+        this.addReferenceCommand = "_chatAgentHostAddReferenceCmd";
+    }
+    constructor(languageFeaturesService, _chatWidgetService, chatSessionsService) {
+        super(languageFeaturesService, chatSessionsService);
+        this._chatWidgetService = _chatWidgetService;
+        this._registrations = this._register(( new DisposableMap()));
+        this._register(
+            CommandsRegistry.registerCommand(AgentHostInputCompletions_1.addReferenceCommand, (_services, arg) => {
+                assertType(arg instanceof AgentHostReferenceArgument);
+                arg.widget.getContrib(ChatDynamicVariableModel.ID)?.addReference({
+                    id: ( arg.uri.toString()),
+                    range: arg.range,
+                    isFile: !arg.isDirectory,
+                    isDirectory: arg.isDirectory,
+                    fullName: arg.displayName,
+                    data: arg.uri,
+                    _meta: arg._meta
+                });
+            })
+        );
+        for (const scheme of this._chatSessionsService.getContentProviderSchemes()) {
+            void this._registerForScheme(scheme);
+        }
+        this._register(this._chatSessionsService.onDidChangeContentProviderSchemes((
+            {
+                added,
+                removed
+            }
+        ) => {
+            for (const scheme of removed) {
+                this._registrations.deleteAndDispose(scheme);
+            }
+            for (const scheme of added) {
+                void this._registerForScheme(scheme);
+            }
+        }));
+    }
+    async _registerForScheme(scheme) {
+        if (!isAgentHostTarget(scheme)) {
+            return;
+        }
+        const triggerCharacters = await this._chatSessionsService.getChatInputCompletionTriggerCharacters(scheme);
+        if (!triggerCharacters || triggerCharacters.length === 0) {
+            return;
+        }
+        if (!this._chatSessionsService.getContentProviderSchemes().includes(scheme)) {
+            return;
+        }
+        this._registrations.set(scheme, this._registerProvider({
+            scheme: Schemas.vscodeChatInput,
+            hasAccessToAllModels: true
+        }, `agentHostChatInputCompletions[${scheme}]`, triggerCharacters, scheme));
+    }
+    _resolveContext(model, scheme) {
+        const widget = this._chatWidgetService.getWidgetByInputUri(model.uri);
+        if (!widget?.viewModel) {
+            return undefined;
+        }
+        const sessionResource = widget.viewModel.model.sessionResource;
+        if (getChatSessionType(sessionResource) !== scheme) {
+            return undefined;
+        }
+        return {
+            sessionResource,
+            context: widget
+        };
+    }
+    _buildItem(position, item, widget) {
+        const replaceRange = AgentHostInputCompletions_1.computeRange(position, item);
+        const label = item.attachment.displayName ?? item.insertText;
+        const description = item.attachment.uri.path;
+        return {
+            label: {
+                label,
+                description
+            },
+            insertText: item.insertText,
+            filterText: item.insertText,
+            range: replaceRange,
+            kind: item.attachment.isDirectory ? CompletionItemKind.Folder : CompletionItemKind.File,
+            command: {
+                id: AgentHostInputCompletions_1.addReferenceCommand,
+                title: "",
+                arguments: [( new AgentHostReferenceArgument(
+                    widget,
+                    item.attachment.uri,
+                    item.attachment.displayName,
+                    !!item.attachment.isDirectory,
+                    replaceRange.replace.setEndPosition(
+                        replaceRange.replace.startLineNumber,
+                        replaceRange.replace.startColumn + item.insertText.length
+                    ),
+                    item.attachment._meta
+                ))]
+            }
+        };
+    }
+};
+AgentHostInputCompletions = AgentHostInputCompletions_1 = ( __decorate([( __param(0, ILanguageFeaturesService)), ( __param(1, IChatWidgetService)), ( __param(2, IChatSessionsService))], AgentHostInputCompletions));
+class AgentHostReferenceArgument {
+    constructor(widget, uri, displayName, isDirectory, range, _meta) {
+        this.widget = widget;
+        this.uri = uri;
+        this.displayName = displayName;
+        this.isDirectory = isDirectory;
+        this.range = range;
+        this._meta = _meta;
+    }
+}
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(AgentHostInputCompletions, LifecyclePhase.Eventually);
+
+export { AgentHostInputCompletions };

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

@@ -0,0 +1,72 @@
+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 { 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 { CompletionItem } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { LanguageFilter } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languageSelector";
+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";
+/**
+ * Shared plumbing for Monaco completion providers that delegate to an
+ * agent host's `provideChatInputCompletions` RPC.
+ *
+ * Subclasses own the registration lifecycle (per-scheme, per-active-
+ * session, etc.) and supply two pieces of behaviour:
+ *
+ *   - {@link _resolveContext}: how to find the session resource for a
+ *     given input model, plus any subclass-specific data ({@link TContext})
+ *     that needs to flow into the accept command. Receives the per-
+ *     registration data ({@link TRegData}) the subclass passed to
+ *     {@link _registerProvider} so it can short-circuit when the model
+ *     does not belong to *this* registration (e.g. a different scheme).
+ *   - {@link _buildItem}: how to produce the final Monaco
+ *     {@link CompletionItem} including the command that runs when the
+ *     user accepts a suggestion.
+ *
+ * The base handles the cross-cutting concerns: gating on trigger
+ * characters, performing the host RPC, cancellation, and registering
+ * the Monaco provider with the host-announced trigger characters.
+ */
+export declare abstract class AgentHostInputCompletionsBase<TContext, TRegData = void> extends Disposable {
+    protected readonly _languageFeaturesService: ILanguageFeaturesService;
+    protected readonly _chatSessionsService: IChatSessionsService;
+    constructor(_languageFeaturesService: ILanguageFeaturesService, _chatSessionsService: IChatSessionsService);
+    /**
+     * Resolve the session resource whose host should answer completions
+     * for `model`, along with any subclass-specific context that should
+     * flow into {@link _buildItem}. Return `undefined` to skip.
+     */
+    protected abstract _resolveContext(model: ITextModel, regData: TRegData): {
+        sessionResource: URI;
+        context: TContext;
+    } | undefined;
+    /**
+     * Build the Monaco completion item — including the accept command —
+     * for one item returned by the host.
+     */
+    protected abstract _buildItem(position: Position, item: IChatInputCompletionItem, context: TContext): CompletionItem;
+    /**
+     * Register a Monaco completion provider that delegates to this
+     * instance. Subclasses call this once their lifecycle decides a
+     * registration should exist (e.g. once a content provider becomes
+     * available, or once the active session changes to an AHP-backed
+     * one). The opaque {@link regData} is forwarded to
+     * {@link _resolveContext} so the subclass can identify which
+     * registration is firing (e.g. its scheme) and ignore models that
+     * don't belong to it.
+     */
+    protected _registerProvider(filter: LanguageFilter, debugName: string, triggerCharacters: readonly string[], regData: TRegData): IDisposable;
+    private _provide;
+    /**
+     * Compute the insert/replace ranges for an item. Positions returned
+     * by the host are already 1-based Monaco positions, so they can be
+     * used directly. When omitted, the ranges default to a zero-length
+     * span at the cursor (Monaco then inserts without replacing).
+     */
+    protected static computeRange(position: Position, item: IChatInputCompletionItem): {
+        insert: Range;
+        replace: Range;
+    };
+}

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

@@ -0,0 +1,56 @@
+
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { isAtTriggerCharacterToken } from './chatInputCompletionUtils.js';
+
+class AgentHostInputCompletionsBase extends Disposable {
+    constructor(_languageFeaturesService, _chatSessionsService) {
+        super();
+        this._languageFeaturesService = _languageFeaturesService;
+        this._chatSessionsService = _chatSessionsService;
+    }
+    _registerProvider(filter, debugName, triggerCharacters, regData) {
+        return this._languageFeaturesService.completionProvider.register(filter, {
+            _debugDisplayName: debugName,
+            triggerCharacters: [...triggerCharacters],
+            provideCompletionItems: (model, position, _context, token) => this._provide(model, position, token, triggerCharacters, regData)
+        });
+    }
+    async _provide(model, position, token, triggerCharacters, regData) {
+        if (!isAtTriggerCharacterToken(model, position, triggerCharacters)) {
+            return null;
+        }
+        const ctx = this._resolveContext(model, regData);
+        if (!ctx) {
+            return null;
+        }
+        const text = model.getValue();
+        const offset = model.getOffsetAt(position);
+        const result = await this._chatSessionsService.provideChatInputCompletions(ctx.sessionResource, {
+            text,
+            offset
+        }, token);
+        if (token.isCancellationRequested || !result) {
+            return null;
+        }
+        const suggestions = [];
+        for (const item of result.items) {
+            suggestions.push(this._buildItem(position, item, ctx.context));
+        }
+        return {
+            suggestions
+        };
+    }
+    static computeRange(position, item) {
+        const start = item.start ?? position;
+        const end = item.end ?? position;
+        const replace = ( new Range(start.lineNumber, start.column, end.lineNumber, end.column));
+        const insert = ( new Range(start.lineNumber, start.column, position.lineNumber, position.column));
+        return {
+            insert,
+            replace
+        };
+    }
+}
+
+export { AgentHostInputCompletionsBase };

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

@@ -10,3 +10,10 @@ export interface IChatCompletionRangeResult {
 }
 export declare function computeCompletionRanges(model: ITextModel, position: Position, reg: RegExp, onlyOnWordStart?: boolean): IChatCompletionRangeResult | undefined;
 export declare function isEmptyUpToCompletionWord(model: ITextModel, rangeResult: IChatCompletionRangeResult): boolean;
+/**
+ * Returns `true` when the cursor sits inside a non-empty token whose first
+ * character is one of the given trigger characters (or is positioned right
+ * after such a token). Used to gate completion providers so they only run
+ * when the user is actively editing a trigger-led token.
+ */
+export declare function isAtTriggerCharacterToken(model: ITextModel, position: Position, triggerCharacters: readonly string[]): boolean;

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

@@ -58,5 +58,18 @@ function isEmptyUpToCompletionWord(model, rangeResult) {
     const startToCompletionWordStart = ( new Range(1, 1, rangeResult.replace.startLineNumber, rangeResult.replace.startColumn));
     return !!model.getValueInRange(startToCompletionWordStart).match(/^\s*$/);
 }
+function isAtTriggerCharacterToken(model, position, triggerCharacters) {
+    if (triggerCharacters.length === 0) {
+        return false;
+    }
+    const line = model.getLineContent(position.lineNumber);
+    const beforeCursor = line.slice(0, position.column - 1);
+    const wsIdx = beforeCursor.search(/\s\S*$/);
+    const token = wsIdx >= 0 ? beforeCursor.slice(wsIdx + 1) : beforeCursor;
+    if (token.length === 0) {
+        return false;
+    }
+    return triggerCharacters.includes(token[0]);
+}
 
-export { computeCompletionRanges, escapeForCharClass, isEmptyUpToCompletionWord };
+export { computeCompletionRanges, escapeForCharClass, isAtTriggerCharacterToken, isEmptyUpToCompletionWord };

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

@@ -47,12 +47,10 @@ import { ChatRequestAgentPart, chatSubcommandLeader, chatAgentLeader, ChatReques
 import { IChatSlashCommandService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatSlashCommands.service';
 import { ChatModeKind, ChatAgentLocation, isSupportedChatFileScheme } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { isToolSet } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { isAgentHostTarget } 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 { getActiveHarnessSlashCommands } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/customizationHarnessService';
 import { ICustomizationHarnessService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/customizationHarnessService.service';
 import { matchesSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
-import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
-import { Target } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
 import { ChatSubmitAction } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/actions/chatExecuteActions';
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
 import { resizeImage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatImageUtils';
@@ -65,12 +63,15 @@ import { AgentSessionProviders, getAgentSessionProviderIcon } from '@codingame/m
 var BuiltinDynamicCompletions_1, ToolCompletions_1;
 const SlashCommandWord = /\/[\p{L}0-9_.:-]*/gu;
 const AgentOrSlashCommandWord = /(@|\/)[\p{L}0-9_.:-]*/gu;
+function isAgentHostBackedWidget(widget) {
+    const sessionResource = widget.viewModel?.model.sessionResource;
+    return !!sessionResource && isAgentHostTarget(getChatSessionType(sessionResource));
+}
 let SlashCommandCompletions = class SlashCommandCompletions extends Disposable {
     constructor(
         languageFeaturesService,
         chatWidgetService,
         chatSlashCommandService,
-        promptsService,
         harnessService,
         chatService,
         chatSessionsService,
@@ -80,7 +81,6 @@ let SlashCommandCompletions = class SlashCommandCompletions extends Disposable {
         this.languageFeaturesService = languageFeaturesService;
         this.chatWidgetService = chatWidgetService;
         this.chatSlashCommandService = chatSlashCommandService;
-        this.promptsService = promptsService;
         this.harnessService = harnessService;
         this._register(this.languageFeaturesService.completionProvider.register({
             scheme: Schemas.vscodeChatInput,
@@ -93,11 +93,6 @@ let SlashCommandCompletions = class SlashCommandCompletions extends Disposable {
                 if (!widget || !widget.viewModel) {
                     return null;
                 }
-                let customAgentTarget = undefined;
-                if (widget.lockedAgentId) {
-                    const sessionResource = widget.viewModel.model.sessionResource;
-                    customAgentTarget = (sessionResource ? chatSessionsService.getCustomAgentTargetForSessionType(getChatSessionType(sessionResource)) : undefined) ?? Target.Undefined;
-                }
                 const range = computeCompletionRanges(model, position, SlashCommandWord);
                 if (!range) {
                     return null;
@@ -114,6 +109,7 @@ let SlashCommandCompletions = class SlashCommandCompletions extends Disposable {
                 if (!slashCommands) {
                     return null;
                 }
+                const sessionType = getChatSessionType(widget.viewModel.model.sessionResource);
                 return {
                     suggestions: ( slashCommands.filter(c => {
                         if (!c.silent && !widget.attachmentCapabilities.supportsPromptAttachments) {
@@ -122,15 +118,15 @@ let SlashCommandCompletions = class SlashCommandCompletions extends Disposable {
                         if (c.when && !widget.scopedContextKeyService.contextMatchesRules(c.when)) {
                             return false;
                         }
+                        if (!matchesSessionType(c.sessionTypes, sessionType)) {
+                            return false;
+                        }
                         if (!widget.lockedAgentId) {
                             return true;
                         }
                         if (c.modes && c.modes.length && !c.modes.includes(ChatModeKind.Agent)) {
                             return false;
                         }
-                        if (c.targets && customAgentTarget && !c.targets.includes(customAgentTarget)) {
-                            return false;
-                        }
                         return true;
                     }).map((c, i) => {
                         const withSlash = `/${c.command}`;
@@ -182,8 +178,9 @@ let SlashCommandCompletions = class SlashCommandCompletions extends Disposable {
                 if (widget.lockedAgentId) {
                     return null;
                 }
+                const currentSessionType = getChatSessionType(widget.viewModel.model.sessionResource);
                 return {
-                    suggestions: ( slashCommands.filter(c => !c.when || widget.scopedContextKeyService.contextMatchesRules(c.when)).map((c, i) => {
+                    suggestions: ( slashCommands.filter(c => !c.when || widget.scopedContextKeyService.contextMatchesRules(c.when)).filter(c => matchesSessionType(c.sessionTypes, currentSessionType)).map((c, i) => {
                         const withSlash = `${chatSubcommandLeader}${c.command}`;
                         return {
                             label: {
@@ -232,14 +229,14 @@ let SlashCommandCompletions = class SlashCommandCompletions extends Disposable {
                 if (usedAgent) {
                     return;
                 }
-                const promptCommands = await getActiveHarnessSlashCommands(this.harnessService, this.promptsService, token);
+                const currentSessionType = getChatSessionType(widget.viewModel.model.sessionResource);
+                const promptCommands = await this.harnessService.getSlashCommands(currentSessionType, token);
                 if (promptCommands.length === 0) {
                     return null;
                 }
                 if (widget.lockedAgentId && !widget.attachmentCapabilities.supportsPromptAttachments) {
                     return null;
                 }
-                const currentSessionType = widget.viewModel.model.sessionResource ? getChatSessionType(widget.viewModel.model.sessionResource) : undefined;
                 const userInvocableCommands = promptCommands.filter(c => c.userInvocable).filter(c => matchesSessionType(c.sessionTypes, currentSessionType));
                 if (userInvocableCommands.length === 0) {
                     return null;
@@ -307,7 +304,7 @@ let SlashCommandCompletions = class SlashCommandCompletions extends Disposable {
         }));
     }
 };
-SlashCommandCompletions = ( __decorate([( __param(0, ILanguageFeaturesService)), ( __param(1, IChatWidgetService)), ( __param(2, IChatSlashCommandService)), ( __param(3, IPromptsService)), ( __param(4, ICustomizationHarnessService)), ( __param(5, IChatService)), ( __param(6, IChatSessionsService)), ( __param(7, IMcpService))], SlashCommandCompletions));
+SlashCommandCompletions = ( __decorate([( __param(0, ILanguageFeaturesService)), ( __param(1, IChatWidgetService)), ( __param(2, IChatSlashCommandService)), ( __param(3, ICustomizationHarnessService)), ( __param(4, IChatService)), ( __param(5, IChatSessionsService)), ( __param(6, IMcpService))], SlashCommandCompletions));
 ( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(SlashCommandCompletions, LifecyclePhase.Eventually);
 let AgentCompletions = class AgentCompletions extends Disposable {
     constructor(
@@ -331,6 +328,9 @@ let AgentCompletions = class AgentCompletions extends Disposable {
                 if (!widget || !widget.viewModel) {
                     return;
                 }
+                if (isAgentHostBackedWidget(widget)) {
+                    return;
+                }
                 const range = computeCompletionRanges(model, position, SlashCommandWord);
                 if (!range) {
                     return;
@@ -369,6 +369,9 @@ let AgentCompletions = class AgentCompletions extends Disposable {
                 if (!widget || !viewModel) {
                     return;
                 }
+                if (isAgentHostBackedWidget(widget)) {
+                    return;
+                }
                 if (widget.lockedAgentId) {
                     return null;
                 }
@@ -470,6 +473,9 @@ let AgentCompletions = class AgentCompletions extends Disposable {
                 if (!widget || !viewModel) {
                     return;
                 }
+                if (isAgentHostBackedWidget(widget)) {
+                    return;
+                }
                 if (widget.lockedAgentId) {
                     return null;
                 }
@@ -542,6 +548,9 @@ let AgentCompletions = class AgentCompletions extends Disposable {
                 if (widget?.location !== ChatAgentLocation.Chat || widget.input.currentModeKind !== ChatModeKind.Ask) {
                     return;
                 }
+                if (isAgentHostBackedWidget(widget)) {
+                    return;
+                }
                 if (widget.lockedAgentId) {
                     return null;
                 }
@@ -552,7 +561,7 @@ let AgentCompletions = class AgentCompletions extends Disposable {
                 if (!isEmptyUpToCompletionWord(model, range)) {
                     return;
                 }
-                const label = ( localize(7202, "Install Chat Extensions..."));
+                const label = ( localize(7507, "Install Chat Extensions..."));
                 const item = {
                     label,
                     insertText: "",
@@ -700,7 +709,7 @@ class StartParameterizedPromptAction extends Action2 {
                 messages = await prompt.resolve(args, cts.token);
             } catch (e) {
                 if (!cts.token.isCancellationRequested) {
-                    notificationService.error(( localize(7203, "Error resolving prompt: {0}", String(e))));
+                    notificationService.error(( localize(7508, "Error resolving prompt: {0}", String(e))));
                 }
                 replaceTextWith("");
                 return;
@@ -728,15 +737,15 @@ class StartParameterizedPromptAction extends Action2 {
                             id: generateUuid(),
                             kind: "generic",
                             value: contents,
-                            name: ( localize(7204, "Prompt Resource"))
+                            name: ( localize(7509, "Prompt Resource"))
                         });
                     }
                 } else if (mimeType && getAttachableImageExtension(mimeType)) {
                     const resized = await resizeImage(contents).catch(() => decodeBase64(contents).buffer);
                     chatWidget.attachmentModel.addContext({
                         id: generateUuid(),
-                        name: ( localize(7205, "Prompt Image")),
-                        fullName: ( localize(7205, "Prompt Image")),
+                        name: ( localize(7510, "Prompt Image")),
+                        fullName: ( localize(7510, "Prompt Image")),
                         value: resized,
                         kind: "image",
                         references: validURI && [{
@@ -1033,7 +1042,7 @@ let BuiltinDynamicCompletions = class BuiltinDynamicCompletions extends Disposab
                 result.suggestions.push({
                     label: {
                         label: sessionPrefix,
-                        description: ( localize(7206, "Attach a chat session"))
+                        description: ( localize(7511, "Attach a chat session"))
                     },
                     filterText: sessionPrefix,
                     insertText: `${sessionPrefix}:`,
@@ -1094,6 +1103,9 @@ let BuiltinDynamicCompletions = class BuiltinDynamicCompletions extends Disposab
                 if (!widget) {
                     return;
                 }
+                if (isAgentHostBackedWidget(widget)) {
+                    return;
+                }
                 const range = computeCompletionRanges(model, position, wordPattern, true);
                 if (range) {
                     return provider({
@@ -1116,7 +1128,7 @@ let BuiltinDynamicCompletions = class BuiltinDynamicCompletions extends Disposab
             const uriLabel = this.labelService.getUriLabel(resource, {
                 relative: true
             });
-            const labelDescription = description ? ( localize(7207, "{0} ({1})", uriLabel, description)) : uriLabel;
+            const labelDescription = description ? ( localize(7512, "{0} ({1})", uriLabel, description)) : uriLabel;
             const sortText = boostPriority ? " " : "!";
             return {
                 label: {
@@ -1168,7 +1180,7 @@ let BuiltinDynamicCompletions = class BuiltinDynamicCompletions extends Disposab
                 }
             }
             seen.add(resource);
-            const newLen = result.suggestions.push(makeCompletionItem(resource, FileKind.FILE, i === 0 ? ( localize(7208, "Active file")) : undefined, i === 0));
+            const newLen = result.suggestions.push(makeCompletionItem(resource, FileKind.FILE, i === 0 ? ( localize(7513, "Active file")) : undefined, i === 0));
             if (newLen - len >= 5) {
                 break;
             }
@@ -1320,6 +1332,9 @@ let ToolCompletions = class ToolCompletions extends Disposable {
                 if (!widget) {
                     return null;
                 }
+                if (isAgentHostBackedWidget(widget)) {
+                    return null;
+                }
                 if (widget.lockedAgentId) {
                     const agent = this.chatAgentService.getAgent(widget.lockedAgentId);
                     if (agent && !agent.capabilities?.supportsToolAttachments) {
@@ -1354,7 +1369,7 @@ let ToolCompletions = class ToolCompletions extends Disposable {
                         name = item.referenceName;
                     } else {
                         const source = item.source;
-                        detail = ( localize(7209, "{0}: {1}", source.label, item.displayName));
+                        detail = ( localize(7514, "{0}: {1}", source.label, item.displayName));
                         name = item.toolReferenceName ?? item.displayName;
                         documentation = item.userDescription ?? item.modelDescription;
                     }