@codingame/monaco-vscode-chat-service-override 20.4.1 → 21.0.0

package/vscode/src/vs/workbench/contrib/chat/common/chatServiceTelemetry.d.ts

@@ -1,8 +1,134 @@
 import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
-import { IChatUserActionEvent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
+import { IChatAgentData } from "@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/common/chatAgents";
+import { ChatRequestModel } from "@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatModel";
+import { ChatRequestAgentPart, ChatRequestAgentSubcommandPart, ChatRequestSlashCommandPart } from "@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/common/chatParserTypes";
+import { IChatSendRequestOptions, IChatUserActionEvent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
+import { ChatAgentLocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+export type ChatProviderInvokedEvent = {
+    timeToFirstProgress: number | undefined;
+    totalTime: number | undefined;
+    result: "success" | "error" | "errorWithOutput" | "cancelled" | "filtered";
+    requestType: "string" | "followup" | "slashCommand";
+    chatSessionId: string;
+    agent: string;
+    agentExtensionId: string | undefined;
+    slashCommand: string | undefined;
+    location: ChatAgentLocation;
+    citations: number;
+    numCodeBlocks: number;
+    isParticipantDetected: boolean;
+    enableCommandDetection: boolean;
+    attachmentKinds: string[];
+    model: string | undefined;
+};
+export type ChatProviderInvokedClassification = {
+    timeToFirstProgress: {
+        classification: "SystemMetaData";
+        purpose: "PerformanceAndHealth";
+        comment: "The time in milliseconds from invoking the provider to getting the first data.";
+    };
+    totalTime: {
+        classification: "SystemMetaData";
+        purpose: "PerformanceAndHealth";
+        comment: "The total time it took to run the provider's `provideResponseWithProgress`.";
+    };
+    result: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "Whether invoking the ChatProvider resulted in an error.";
+    };
+    requestType: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The type of request that the user made.";
+    };
+    chatSessionId: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "A random ID for the session.";
+    };
+    agent: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The type of agent used.";
+    };
+    agentExtensionId: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The extension that contributed the agent.";
+    };
+    slashCommand?: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The type of slashCommand used.";
+    };
+    location: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The location at which chat request was made.";
+    };
+    citations: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The number of public code citations that were returned with the response.";
+    };
+    numCodeBlocks: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The number of code blocks in the response.";
+    };
+    isParticipantDetected: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "Whether the participant was automatically detected.";
+    };
+    enableCommandDetection: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "Whether participation detection was disabled for this invocation.";
+    };
+    attachmentKinds: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The types of variables/attachments that the user included with their query.";
+    };
+    model: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The model used to generate the response.";
+    };
+    owner: "roblourens";
+    comment: "Provides insight into the performance of Chat agents.";
+};
 export declare class ChatServiceTelemetry {
     private readonly telemetryService;
     constructor(telemetryService: ITelemetryService);
     notifyUserAction(action: IChatUserActionEvent): void;
     retrievedFollowups(agentId: string, command: string | undefined, numFollowups: number): void;
 }
+export declare class ChatRequestTelemetry {
+    private readonly opts;
+    private readonly telemetryService;
+    private readonly languageModelsService;
+    private isComplete;
+    constructor(opts: {
+        agentPart: ChatRequestAgentPart | undefined;
+        agentSlashCommandPart: ChatRequestAgentSubcommandPart | undefined;
+        commandPart: ChatRequestSlashCommandPart | undefined;
+        sessionId: string;
+        location: ChatAgentLocation;
+        options: IChatSendRequestOptions | undefined;
+        enableCommandDetection: boolean;
+    }, telemetryService: ITelemetryService, languageModelsService: ILanguageModelsService);
+    complete({ timeToFirstProgress, totalTime, result, requestType, request, detectedAgent }: {
+        timeToFirstProgress: number | undefined;
+        totalTime: number | undefined;
+        result: ChatProviderInvokedEvent["result"];
+        requestType: ChatProviderInvokedEvent["requestType"];
+        request: ChatRequestModel;
+        detectedAgent: IChatAgentData | undefined;
+    }): void;
+    private attachmentKindsForTelemetry;
+    private resolveModelId;
+}

package/vscode/src/vs/workbench/contrib/chat/common/chatServiceTelemetry.js

@@ -1,7 +1,11 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { isLocation } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
 import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
 import { ChatAgentVoteDirection, ChatCopyKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService';
+import { isImageVariableEntry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatVariableEntries';
+import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
 
 let ChatServiceTelemetry = class ChatServiceTelemetry {
     constructor(telemetryService) {
@@ -72,5 +76,111 @@ let ChatServiceTelemetry = class ChatServiceTelemetry {
 ChatServiceTelemetry = ( __decorate([
     ( __param(0, ITelemetryService))
 ], ChatServiceTelemetry));
+function getCodeBlocks(text) {
+    const lines = text.split('\n');
+    const codeBlockLanguages = [];
+    let codeBlockState;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (codeBlockState) {
+            if (( new RegExp(`^\\s*${codeBlockState.delimiter}\\s*$`)).test(line)) {
+                codeBlockLanguages.push(codeBlockState.languageId);
+                codeBlockState = undefined;
+            }
+        }
+        else {
+            const match = line.match(/^(\s*)(`{3,}|~{3,})(\w*)/);
+            if (match) {
+                codeBlockState = { delimiter: match[2], languageId: match[3] };
+            }
+        }
+    }
+    return codeBlockLanguages;
+}
+let ChatRequestTelemetry = class ChatRequestTelemetry {
+    constructor(opts, telemetryService, languageModelsService) {
+        this.opts = opts;
+        this.telemetryService = telemetryService;
+        this.languageModelsService = languageModelsService;
+        this.isComplete = false;
+    }
+    complete({ timeToFirstProgress, totalTime, result, requestType, request, detectedAgent }) {
+        if (this.isComplete) {
+            return;
+        }
+        this.isComplete = true;
+        this.telemetryService.publicLog2('interactiveSessionProviderInvoked', {
+            timeToFirstProgress,
+            totalTime,
+            result,
+            requestType,
+            agent: detectedAgent?.id ?? this.opts.agentPart?.agent.id ?? '',
+            agentExtensionId: detectedAgent?.extensionId.value ?? this.opts.agentPart?.agent.extensionId.value ?? '',
+            slashCommand: this.opts.agentSlashCommandPart ? this.opts.agentSlashCommandPart.command.name : this.opts.commandPart?.slashCommand.command,
+            chatSessionId: this.opts.sessionId,
+            enableCommandDetection: this.opts.enableCommandDetection,
+            isParticipantDetected: !!detectedAgent,
+            location: this.opts.location,
+            citations: request.response?.codeCitations.length ?? 0,
+            numCodeBlocks: getCodeBlocks(request.response?.response.toString() ?? '').length,
+            attachmentKinds: this.attachmentKindsForTelemetry(request.variableData),
+            model: this.resolveModelId(this.opts.options?.userSelectedModelId),
+        });
+    }
+    attachmentKindsForTelemetry(variableData) {
+        return ( variableData.variables.map(v => {
+            if (v.kind === 'implicit') {
+                return 'implicit';
+            }
+            else if (v.range) {
+                if (v.kind === 'tool') {
+                    return 'toolInPrompt';
+                }
+                else if (v.kind === 'toolset') {
+                    return 'toolsetInPrompt';
+                }
+                else {
+                    return 'fileInPrompt';
+                }
+            }
+            else if (v.kind === 'command') {
+                return 'command';
+            }
+            else if (v.kind === 'symbol') {
+                return 'symbol';
+            }
+            else if (isImageVariableEntry(v)) {
+                return 'image';
+            }
+            else if (v.kind === 'directory') {
+                return 'directory';
+            }
+            else if (v.kind === 'tool') {
+                return 'tool';
+            }
+            else if (v.kind === 'toolset') {
+                return 'toolset';
+            }
+            else {
+                if (URI.isUri(v.value)) {
+                    return 'file';
+                }
+                else if (isLocation(v.value)) {
+                    return 'location';
+                }
+                else {
+                    return 'otherAttachment';
+                }
+            }
+        }));
+    }
+    resolveModelId(userSelectedModelId) {
+        return userSelectedModelId && this.languageModelsService.lookupLanguageModel(userSelectedModelId)?.id;
+    }
+};
+ChatRequestTelemetry = ( __decorate([
+    ( __param(1, ITelemetryService)),
+    ( __param(2, ILanguageModelsService))
+], ChatRequestTelemetry));
 
-export { ChatServiceTelemetry };
+export { ChatRequestTelemetry, ChatServiceTelemetry };

package/vscode/src/vs/workbench/contrib/chat/common/chatSessionStore.js

@@ -51,7 +51,7 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
             }
             e.join(this.storeTask, {
                 id: 'join.chatSessionStore',
-                label: ( localize(5418, "Saving chat history"))
+                label: ( localize(5546, "Saving chat history"))
             });
         }));
     }
@@ -324,8 +324,8 @@ function isChatSessionIndex(data) {
 }
 function getSessionMetadata(session) {
     const title = session instanceof ChatModel ?
-        (session.title || ( localize(5419, "New Chat"))) :
-        session.customTitle ?? ChatModel.getDefaultTitle(session.requests);
+        session.customTitle || (session.getRequests().length > 0 ? ChatModel.getDefaultTitle(session.getRequests()) : '') :
+        session.customTitle ?? (session.requests.length > 0 ? ChatModel.getDefaultTitle(session.requests) : '');
     return {
         sessionId: session.sessionId,
         title,

package/vscode/src/vs/workbench/contrib/chat/common/chatTodoListService.d.ts

@@ -23,5 +23,6 @@ export declare class ChatTodoListService extends Disposable implements IChatTodo
     readonly _serviceBrand: undefined;
     private todoListStorage;
     constructor(storageService: IStorageService);
-    getChatTodoListStorage(): IChatTodoListStorage;
+    getTodos(sessionId: string): IChatTodo[];
+    setTodos(sessionId: string, todos: IChatTodo[]): void;
 }

package/vscode/src/vs/workbench/contrib/chat/common/chatTodoListService.js

@@ -3,7 +3,7 @@ import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
-import { Memento } from '@codingame/monaco-vscode-60014c9d-b815-501d-83a9-4b08725c2ec2-common/vscode/vs/workbench/common/memento';
+import { Memento } from '@codingame/monaco-vscode-23b6fb38-5e58-5886-b34b-27abc4f5df02-common/vscode/vs/workbench/common/memento';
 
 let ChatTodoListStorage = class ChatTodoListStorage {
     constructor(storageService) {
@@ -33,8 +33,11 @@ let ChatTodoListService = class ChatTodoListService extends Disposable {
         super();
         this.todoListStorage = ( new ChatTodoListStorage(storageService));
     }
-    getChatTodoListStorage() {
-        return this.todoListStorage;
+    getTodos(sessionId) {
+        return this.todoListStorage.getTodoList(sessionId);
+    }
+    setTodos(sessionId, todos) {
+        this.todoListStorage.setTodoList(sessionId, todos);
     }
 };
 ChatTodoListService = ( __decorate([

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/languageProviders/PromptHeaderDefinitionProvider.d.ts

@@ -0,0 +1,20 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { Position } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position";
+import { Definition, DefinitionProvider } 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 { IChatModeService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes.service";
+import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service";
+export declare class PromptHeaderDefinitionProvider extends Disposable implements DefinitionProvider {
+    private readonly promptsService;
+    private readonly languageService;
+    private readonly chatModeService;
+    /**
+     * Debug display name for this provider.
+     */
+    readonly _debugDisplayName: string;
+    constructor(promptsService: IPromptsService, languageService: ILanguageFeaturesService, chatModeService: IChatModeService);
+    provideDefinition(model: ITextModel, position: Position, token: CancellationToken): Promise<Definition | undefined>;
+    private getModeDefinition;
+}

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/languageProviders/PromptHeaderDefinitionProvider.js

@@ -0,0 +1,66 @@
+
+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 { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
+import { IChatModeService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes.service';
+import { ALL_PROMPTS_LANGUAGE_SELECTOR, getPromptsTypeForLanguageId } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
+import { PromptHeader } from '../parsers/promptHeader/promptHeader.js';
+
+let PromptHeaderDefinitionProvider = class PromptHeaderDefinitionProvider extends Disposable {
+    constructor(promptsService, languageService, chatModeService) {
+        super();
+        this.promptsService = promptsService;
+        this.languageService = languageService;
+        this.chatModeService = chatModeService;
+        this._debugDisplayName = 'PromptHeaderHoverProvider';
+        this._register(this.languageService.definitionProvider.register(ALL_PROMPTS_LANGUAGE_SELECTOR, this));
+    }
+    async provideDefinition(model, position, token) {
+        const promptType = getPromptsTypeForLanguageId(model.getLanguageId());
+        if (!promptType) {
+            return undefined;
+        }
+        const parser = this.promptsService.getSyntaxParserFor(model);
+        await parser.start(token).settled();
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        const header = parser.header;
+        if (!header) {
+            return undefined;
+        }
+        const completed = await header.settled;
+        if (!completed || token.isCancellationRequested) {
+            return undefined;
+        }
+        if (header instanceof PromptHeader) {
+            const mode = header.metadataUtility.mode;
+            if (mode?.range.containsPosition(position)) {
+                return this.getModeDefinition(mode, position);
+            }
+        }
+        return undefined;
+    }
+    getModeDefinition(mode, position) {
+        const value = mode.value;
+        if (value && mode.valueRange?.containsPosition(position)) {
+            const mode = this.chatModeService.findModeByName(value);
+            if (mode && mode.uri) {
+                return {
+                    uri: mode.uri.get(),
+                    range: ( new Range(1, 1, 1, 1))
+                };
+            }
+        }
+        return undefined;
+    }
+};
+PromptHeaderDefinitionProvider = ( __decorate([
+    ( __param(0, IPromptsService)),
+    ( __param(1, ILanguageFeaturesService)),
+    ( __param(2, IChatModeService))
+], PromptHeaderDefinitionProvider));
+
+export { PromptHeaderDefinitionProvider };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/languageProviders/promptBodyAutocompletion.d.ts

@@ -0,0 +1,38 @@
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { Position } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { ILanguageFeaturesService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service";
+import { CompletionContext, CompletionItemProvider, CompletionList } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service";
+/**
+ * Provides autocompletion for the variables inside prompt bodies.
+ * - #file: paths to files and folders in the workspace
+ * - # tool names
+ */
+export declare class PromptBodyAutocompletion extends Disposable implements CompletionItemProvider {
+    private readonly fileService;
+    private readonly languageService;
+    private readonly languageModelToolsService;
+    /**
+     * Debug display name for this provider.
+     */
+    readonly _debugDisplayName: string;
+    /**
+     * List of trigger characters handled by this provider.
+     */
+    readonly triggerCharacters: string[];
+    constructor(fileService: IFileService, languageService: ILanguageFeaturesService, languageModelToolsService: ILanguageModelToolsService);
+    /**
+     * The main function of this provider that calculates
+     * completion items based on the provided arguments.
+     */
+    provideCompletionItems(model: ITextModel, position: Position, context: CompletionContext, token: CancellationToken): Promise<CompletionList | undefined>;
+    private collectToolCompletions;
+    private collectFilePathCompletions;
+    /**
+     * Finds a file reference that suites the provided `position`.
+     */
+    private findVariableReference;
+}

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/languageProviders/promptBodyAutocompletion.js

@@ -0,0 +1,143 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { extUri, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ALL_PROMPTS_LANGUAGE_SELECTOR, PromptsType } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
+import { CompletionItemKind } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { CharCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/charCode';
+import { getWordAtText } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/wordHelper';
+import { chatVariableLeader } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
+import { getPromptFileType } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/promptFileLocations';
+
+let PromptBodyAutocompletion = class PromptBodyAutocompletion extends Disposable {
+    constructor(fileService, languageService, languageModelToolsService) {
+        super();
+        this.fileService = fileService;
+        this.languageService = languageService;
+        this.languageModelToolsService = languageModelToolsService;
+        this._debugDisplayName = 'PromptBodyAutocompletion';
+        this.triggerCharacters = [':', '.', '/', '\\'];
+        this._register(this.languageService.completionProvider.register(ALL_PROMPTS_LANGUAGE_SELECTOR, this));
+    }
+    async provideCompletionItems(model, position, context, token) {
+        const reference = await this.findVariableReference(model, position, token);
+        if (!reference) {
+            return undefined;
+        }
+        const suggestions = [];
+        if (reference.type === 'file') {
+            if (reference.contentRange.containsPosition(position)) {
+                await this.collectFilePathCompletions(model, position, reference.contentRange, suggestions);
+            }
+        }
+        else if (reference.type === '') {
+            const promptFileType = getPromptFileType(model.uri);
+            if (promptFileType === PromptsType.mode || promptFileType === PromptsType.prompt) {
+                await this.collectToolCompletions(model, position, reference.contentRange, suggestions);
+            }
+        }
+        return { suggestions };
+    }
+    async collectToolCompletions(model, position, toolRange, suggestions) {
+        const addSuggestion = (toolName, toolRange) => {
+            suggestions.push({
+                label: toolName,
+                kind: CompletionItemKind.Value,
+                filterText: toolName,
+                insertText: toolName,
+                range: toolRange,
+            });
+        };
+        for (const tool of this.languageModelToolsService.getTools()) {
+            if (tool.canBeReferencedInPrompt) {
+                addSuggestion(tool.toolReferenceName ?? tool.displayName, toolRange);
+            }
+        }
+        for (const toolSet of this.languageModelToolsService.toolSets.get()) {
+            addSuggestion(toolSet.referenceName, toolRange);
+        }
+    }
+    async collectFilePathCompletions(model, position, pathRange, suggestions) {
+        const pathUntilPosition = model.getValueInRange(pathRange.setEndPosition(position.lineNumber, position.column));
+        const pathSeparator = pathUntilPosition.includes('/') || !pathUntilPosition.includes('\\') ? '/' : '\\';
+        let parentFolderPath;
+        if (pathUntilPosition.match(/[^\/]\.\.$/i)) {
+            parentFolderPath = pathUntilPosition + pathSeparator;
+        }
+        else {
+            let i = pathUntilPosition.length - 1;
+            while (i >= 0 && ![CharCode.Slash, CharCode.Backslash].includes(pathUntilPosition.charCodeAt(i))) {
+                i--;
+            }
+            parentFolderPath = pathUntilPosition.substring(0, i + 1);
+        }
+        const retriggerCommand = { id: 'editor.action.triggerSuggest', title: 'Suggest' };
+        try {
+            const currentFolder = extUri.resolvePath(dirname(model.uri), parentFolderPath);
+            const { children } = await this.fileService.resolve(currentFolder);
+            if (children) {
+                for (const child of children) {
+                    const insertText = (parentFolderPath || ('.' + pathSeparator)) + child.name;
+                    suggestions.push({
+                        label: child.name + (child.isDirectory ? pathSeparator : ''),
+                        kind: child.isDirectory ? CompletionItemKind.Folder : CompletionItemKind.File,
+                        range: pathRange,
+                        insertText: insertText + (child.isDirectory ? pathSeparator : ''),
+                        filterText: insertText,
+                        command: child.isDirectory ? retriggerCommand : undefined
+                    });
+                }
+            }
+        }
+        catch (e) {
+        }
+        suggestions.push({
+            label: '..',
+            kind: CompletionItemKind.Folder,
+            insertText: parentFolderPath + '..' + pathSeparator,
+            range: pathRange,
+            filterText: parentFolderPath + '..',
+            command: retriggerCommand
+        });
+    }
+    async findVariableReference(model, position, token) {
+        if (model.getLineContent(1).trimEnd() === '---') {
+            let i = 2;
+            while (i <= model.getLineCount() && model.getLineContent(i).trimEnd() !== '---') {
+                i++;
+            }
+            if (i >= position.lineNumber) {
+                return undefined;
+            }
+        }
+        const reg = ( new RegExp(`${chatVariableLeader}[^\\s#]*`, 'g'));
+        const varWord = getWordAtText(position.column, reg, model.getLineContent(position.lineNumber), 0);
+        if (!varWord) {
+            return undefined;
+        }
+        const nameMatch = varWord.word.match(/^#(\w+:)?/);
+        if (nameMatch) {
+            if (nameMatch[1] === 'file:') {
+                const contentCol = varWord.startColumn + nameMatch[0].length;
+                return { type: 'file', contentRange: ( new Range(position.lineNumber, contentCol, position.lineNumber, varWord.endColumn)) };
+            }
+        }
+        return { type: '', contentRange: ( new Range(
+            position.lineNumber,
+            varWord.startColumn + 1,
+            position.lineNumber,
+            varWord.endColumn
+        )) };
+    }
+};
+PromptBodyAutocompletion = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, ILanguageFeaturesService)),
+    ( __param(2, ILanguageModelToolsService))
+], PromptBodyAutocompletion));
+
+export { PromptBodyAutocompletion };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/languageProviders/promptHeaderAutocompletion.d.ts

@@ -6,12 +6,14 @@ import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common
 import { ILanguageFeaturesService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service";
 import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
 import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service";
+import { IChatModeService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes.service";
 import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service";
 export declare class PromptHeaderAutocompletion extends Disposable implements CompletionItemProvider {
     private readonly promptsService;
     private readonly languageService;
     private readonly languageModelsService;
     private readonly languageModelToolsService;
+    private readonly chatModeService;
     /**
      * Debug display name for this provider.
      */
@@ -20,7 +22,7 @@ export declare class PromptHeaderAutocompletion extends Disposable implements Co
      * List of trigger characters handled by this provider.
      */
     readonly triggerCharacters: string[];
-    constructor(promptsService: IPromptsService, languageService: ILanguageFeaturesService, languageModelsService: ILanguageModelsService, languageModelToolsService: ILanguageModelToolsService);
+    constructor(promptsService: IPromptsService, languageService: ILanguageFeaturesService, languageModelsService: ILanguageModelsService, languageModelToolsService: ILanguageModelToolsService, chatModeService: IChatModeService);
     /**
      * The main function of this provider that calculates
      * completion items based on the provided arguments.

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/languageProviders/promptHeaderAutocompletion.js

@@ -9,18 +9,21 @@ import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs
 import { ILanguageModelChatMetadata } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
 import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
 import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
+import { IChatModeService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes.service';
 import { ModeHeader } from '../parsers/promptHeader/modeHeader.js';
 import { PromptHeader } from '../parsers/promptHeader/promptHeader.js';
 import { ALL_PROMPTS_LANGUAGE_SELECTOR, getPromptsTypeForLanguageId, PromptsType } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
 import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
+import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
 
 let PromptHeaderAutocompletion = class PromptHeaderAutocompletion extends Disposable {
-    constructor(promptsService, languageService, languageModelsService, languageModelToolsService) {
+    constructor(promptsService, languageService, languageModelsService, languageModelToolsService, chatModeService) {
         super();
         this.promptsService = promptsService;
         this.languageService = languageService;
         this.languageModelsService = languageModelsService;
         this.languageModelToolsService = languageModelToolsService;
+        this.chatModeService = chatModeService;
         this._debugDisplayName = 'PromptHeaderAutocompletion';
         this.triggerCharacters = [':'];
         this._register(this.languageService.completionProvider.register(ALL_PROMPTS_LANGUAGE_SELECTOR, this));
@@ -162,7 +165,12 @@ let PromptHeaderAutocompletion = class PromptHeaderAutocompletion extends Dispos
             return ['**', '**/*.ts, **/*.js', '**/*.php', '**/*.py'];
         }
         if (promptType === PromptsType.prompt && property === 'mode') {
-            return ['agent', 'edit', 'ask'];
+            const modes = this.chatModeService.getModes();
+            const suggestions = [];
+            for (const mode of Iterable.concat(modes.builtin, modes.custom)) {
+                suggestions.push(mode.name);
+            }
+            return suggestions;
         }
         if (property === 'tools' && (promptType === PromptsType.prompt || promptType === PromptsType.mode)) {
             return ['[]', `['codebase', 'editFiles', 'fetch']`];
@@ -235,7 +243,8 @@ PromptHeaderAutocompletion = ( __decorate([
     ( __param(0, IPromptsService)),
     ( __param(1, ILanguageFeaturesService)),
     ( __param(2, ILanguageModelsService)),
-    ( __param(3, ILanguageModelToolsService))
+    ( __param(3, ILanguageModelToolsService)),
+    ( __param(4, IChatModeService))
 ], PromptHeaderAutocompletion));
 
 export { PromptHeaderAutocompletion };