@codingame/monaco-vscode-chat-service-override 21.6.0 → 22.0.0

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

@@ -0,0 +1,150 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ExtensionsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
+import { joinPath, isEqualOrParent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
+import { PromptsType } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { checkProposedApiEnabled } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions';
+
+function registerChatFilesExtensionPoint(point) {
+    return ExtensionsRegistry.registerExtensionPoint({
+        extensionPoint: point,
+        jsonSchema: {
+            description: ( localize(5620, 'Contributes {0} for chat prompts.', point)),
+            type: 'array',
+            items: {
+                additionalProperties: false,
+                type: 'object',
+                defaultSnippets: [{
+                        body: {
+                            name: 'exampleName',
+                            path: './relative/path/to/file.md',
+                            description: 'Optional description'
+                        }
+                    }],
+                required: ['name', 'path'],
+                properties: {
+                    name: {
+                        description: ( localize(
+                            5621,
+                            'Identifier for this file. Must be unique within this extension for this contribution point.'
+                        )),
+                        type: 'string',
+                        pattern: '^[\\w.-]+$'
+                    },
+                    path: {
+                        description: ( localize(5622, 'Path to the file relative to the extension root.')),
+                        type: 'string'
+                    },
+                    description: {
+                        description: ( localize(5623, '(Optional) Description of the file.')),
+                        type: 'string'
+                    }
+                }
+            }
+        }
+    });
+}
+const epPrompt = registerChatFilesExtensionPoint('chatPromptFiles');
+const epInstructions = registerChatFilesExtensionPoint('chatInstructions');
+const epModes = registerChatFilesExtensionPoint('chatModes');
+function pointToType(contributionPoint) {
+    switch (contributionPoint) {
+        case 'chatPromptFiles': return PromptsType.prompt;
+        case 'chatInstructions': return PromptsType.instructions;
+        case 'chatModes': return PromptsType.mode;
+    }
+}
+function key(extensionId, type, name) {
+    return `${extensionId.value}/${type}/${name}`;
+}
+let ChatPromptFilesExtensionPointHandler = class ChatPromptFilesExtensionPointHandler {
+    static { this.ID = 'workbench.contrib.chatPromptFilesExtensionPointHandler'; }
+    constructor(promptsService) {
+        this.promptsService = promptsService;
+        this.registrations = ( new DisposableMap());
+        this.handle(epPrompt, 'chatPromptFiles');
+        this.handle(epInstructions, 'chatInstructions');
+        this.handle(epModes, 'chatModes');
+    }
+    handle(extensionPoint, contributionPoint) {
+        extensionPoint.setHandler((_extensions, delta) => {
+            for (const ext of delta.added) {
+                if (contributionPoint === 'chatModes') {
+                    checkProposedApiEnabled(ext.description, 'chatParticipantPrivate');
+                }
+                const type = pointToType(contributionPoint);
+                for (const raw of ext.value) {
+                    if (!raw.name || !raw.name.match(/^[\w.-]+$/)) {
+                        ext.collector.error(( localize(
+                            5624,
+                            "Extension '{0}' cannot register {1} entry with invalid name '{2}'.",
+                            ext.description.identifier.value,
+                            contributionPoint,
+                            raw.name
+                        )));
+                        continue;
+                    }
+                    if (!raw.path) {
+                        ext.collector.error(( localize(
+                            5625,
+                            "Extension '{0}' cannot register {1} entry '{2}' without path.",
+                            ext.description.identifier.value,
+                            contributionPoint,
+                            raw.name
+                        )));
+                        continue;
+                    }
+                    if (!raw.description) {
+                        ext.collector.error(( localize(
+                            5626,
+                            "Extension '{0}' cannot register {1} entry '{2}' without description.",
+                            ext.description.identifier.value,
+                            contributionPoint,
+                            raw.name
+                        )));
+                        continue;
+                    }
+                    const fileUri = joinPath(ext.description.extensionLocation, raw.path);
+                    if (!isEqualOrParent(fileUri, ext.description.extensionLocation)) {
+                        ext.collector.error(( localize(
+                            5627,
+                            "Extension '{0}' {1} entry '{2}' path resolves outside the extension.",
+                            ext.description.identifier.value,
+                            contributionPoint,
+                            raw.name
+                        )));
+                        continue;
+                    }
+                    try {
+                        const d = this.promptsService.registerContributedFile(type, raw.name, raw.description, fileUri, ext.description);
+                        this.registrations.set(key(ext.description.identifier, type, raw.name), d);
+                    }
+                    catch (e) {
+                        const msg = e instanceof Error ? e.message : String(e);
+                        ext.collector.error(( localize(
+                            5628,
+                            "Failed to register {0} entry '{1}': {2}",
+                            contributionPoint,
+                            raw.name,
+                            msg
+                        )));
+                    }
+                }
+            }
+            for (const ext of delta.removed) {
+                const type = pointToType(contributionPoint);
+                for (const raw of ext.value) {
+                    this.registrations.deleteAndDispose(key(ext.description.identifier, type, raw.name));
+                }
+            }
+        });
+    }
+};
+ChatPromptFilesExtensionPointHandler = ( __decorate([
+    ( __param(0, IPromptsService))
+], ChatPromptFilesExtensionPointHandler));
+
+export { ChatPromptFilesExtensionPointHandler };

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

@@ -1,20 +1,16 @@
 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 {
+export declare class PromptHeaderDefinitionProvider 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);
+    constructor(promptsService: IPromptsService, 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

@@ -1,52 +1,29 @@
 
 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 { 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();
+let PromptHeaderDefinitionProvider = class PromptHeaderDefinitionProvider {
+    constructor(promptsService, chatModeService) {
         this.promptsService = promptsService;
-        this.languageService = languageService;
         this.chatModeService = chatModeService;
-        this._debugDisplayName = 'PromptHeaderHoverProvider';
-        this._register(this.languageService.definitionProvider.register(ALL_PROMPTS_LANGUAGE_SELECTOR, this));
+        this._debugDisplayName = 'PromptHeaderDefinitionProvider';
     }
     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 parser = this.promptsService.getParsedPromptFile(model);
         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);
+        const modeAttr = header.getAttribute('mode');
+        if (modeAttr && modeAttr.value.type === 'string' && modeAttr.range.containsPosition(position)) {
+            const mode = this.chatModeService.findModeByName(modeAttr.value.value);
             if (mode && mode.uri) {
                 return {
                     uri: mode.uri.get(),
@@ -59,8 +36,7 @@ let PromptHeaderDefinitionProvider = class PromptHeaderDefinitionProvider extend
 };
 PromptHeaderDefinitionProvider = ( __decorate([
     ( __param(0, IPromptsService)),
-    ( __param(1, ILanguageFeaturesService)),
-    ( __param(2, IChatModeService))
+    ( __param(1, IChatModeService))
 ], PromptHeaderDefinitionProvider));
 
 export { PromptHeaderDefinitionProvider };

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

@@ -1,9 +1,7 @@
 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";
 /**
@@ -11,9 +9,8 @@ import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/
  * - #file: paths to files and folders in the workspace
  * - # tool names
  */
-export declare class PromptBodyAutocompletion extends Disposable implements CompletionItemProvider {
+export declare class PromptBodyAutocompletion implements CompletionItemProvider {
     private readonly fileService;
-    private readonly languageService;
     private readonly languageModelToolsService;
     /**
      * Debug display name for this provider.
@@ -23,7 +20,7 @@ export declare class PromptBodyAutocompletion extends Disposable implements Comp
      * List of trigger characters handled by this provider.
      */
     readonly triggerCharacters: string[];
-    constructor(fileService: IFileService, languageService: ILanguageFeaturesService, languageModelToolsService: ILanguageModelToolsService);
+    constructor(fileService: IFileService, languageModelToolsService: ILanguageModelToolsService);
     /**
      * 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/promptBodyAutocompletion.js

@@ -1,10 +1,8 @@
 
 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 { 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';
@@ -13,15 +11,12 @@ import { chatVariableLeader } from '@codingame/monaco-vscode-b994942c-360d-5b68-
 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();
+let PromptBodyAutocompletion = class PromptBodyAutocompletion {
+    constructor(fileService, languageModelToolsService) {
         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);
@@ -43,7 +38,7 @@ let PromptBodyAutocompletion = class PromptBodyAutocompletion extends Disposable
         return { suggestions };
     }
     async collectToolCompletions(model, position, toolRange, suggestions) {
-        const addSuggestion = (toolName, toolRange) => {
+        for (const toolName of this.languageModelToolsService.getQualifiedToolNames()) {
             suggestions.push({
                 label: toolName,
                 kind: CompletionItemKind.Value,
@@ -51,14 +46,6 @@ let PromptBodyAutocompletion = class PromptBodyAutocompletion extends Disposable
                 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) {
@@ -136,8 +123,7 @@ let PromptBodyAutocompletion = class PromptBodyAutocompletion extends Disposable
 };
 PromptBodyAutocompletion = ( __decorate([
     ( __param(0, IFileService)),
-    ( __param(1, ILanguageFeaturesService)),
-    ( __param(2, ILanguageModelToolsService))
+    ( __param(1, ILanguageModelToolsService))
 ], PromptBodyAutocompletion));
 
 export { PromptBodyAutocompletion };

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

@@ -0,0 +1,18 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+import { CodeActionContext, CodeActionList, CodeActionProvider, ProviderResult } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service";
+import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service";
+import { Selection } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/selection";
+export declare class PromptCodeActionProvider implements CodeActionProvider {
+    private readonly promptsService;
+    private readonly languageModelToolsService;
+    /**
+     * Debug display name for this provider.
+     */
+    readonly _debugDisplayName: string;
+    constructor(promptsService: IPromptsService, languageModelToolsService: ILanguageModelToolsService);
+    provideCodeActions(model: ITextModel, range: Range | Selection, context: CodeActionContext, token: CancellationToken): ProviderResult<CodeActionList>;
+    private getUpdateToolsCodeActions;
+}

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

@@ -0,0 +1,83 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
+import { 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 { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+
+let PromptCodeActionProvider = class PromptCodeActionProvider {
+    constructor(promptsService, languageModelToolsService) {
+        this.promptsService = promptsService;
+        this.languageModelToolsService = languageModelToolsService;
+        this._debugDisplayName = 'PromptCodeActionProvider';
+    }
+    provideCodeActions(model, range, context, token) {
+        const promptType = getPromptsTypeForLanguageId(model.getLanguageId());
+        if (!promptType) {
+            return undefined;
+        }
+        const parser = this.promptsService.getParsedPromptFile(model);
+        const toolsAttr = parser.header?.getAttribute('tools');
+        if (!toolsAttr || toolsAttr.value.type !== 'array' || !toolsAttr.value.range.containsRange(range)) {
+            return undefined;
+        }
+        return this.getUpdateToolsCodeActions(toolsAttr.value.items, model, range);
+    }
+    getUpdateToolsCodeActions(values, model, range) {
+        const deprecatedNames = ( new Lazy(() => this.languageModelToolsService.getDeprecatedQualifiedToolNames()));
+        const actions = [];
+        const edits = [];
+        for (const item of values) {
+            if (item.type !== 'string') {
+                continue;
+            }
+            const newName = deprecatedNames.value.get(item.value);
+            if (newName) {
+                const quote = model.getValueInRange(( new Range(
+                    item.range.startLineNumber,
+                    item.range.startColumn,
+                    item.range.endLineNumber,
+                    item.range.startColumn + 1
+                )));
+                const text = (quote === `'` || quote === '"') ? (quote + newName + quote) : newName;
+                const edit = { range: item.range, text };
+                edits.push(edit);
+                if (item.range.containsRange(range)) {
+                    actions.push({
+                        title: ( localize(5636, "Update to '{0}'", newName)),
+                        edit: {
+                            edits: [asWorkspaceTextEdit(model, edit)]
+                        }
+                    });
+                }
+            }
+        }
+        if (edits.length && actions.length === 0 || edits.length > 1) {
+            actions.push({
+                title: ( localize(5637, "Update all tool names")),
+                edit: {
+                    edits: ( edits.map(edit => asWorkspaceTextEdit(model, edit)))
+                }
+            });
+        }
+        if (actions.length) {
+            return { actions, dispose: () => { } };
+        }
+        return undefined;
+    }
+};
+PromptCodeActionProvider = ( __decorate([
+    ( __param(0, IPromptsService)),
+    ( __param(1, ILanguageModelToolsService))
+], PromptCodeActionProvider));
+function asWorkspaceTextEdit(model, textEdit) {
+    return {
+        versionId: model.getVersionId(),
+        resource: model.uri,
+        textEdit
+    };
+}
+
+export { PromptCodeActionProvider };

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

@@ -0,0 +1,15 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { DocumentSemanticTokensProvider, ProviderResult, SemanticTokens, SemanticTokensLegend } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service";
+export declare class PromptDocumentSemanticTokensProvider implements DocumentSemanticTokensProvider {
+    private readonly promptsService;
+    /**
+     * Debug display name for this provider.
+     */
+    readonly _debugDisplayName: string;
+    constructor(promptsService: IPromptsService);
+    provideDocumentSemanticTokens(model: ITextModel, lastResultId: string | null, token: CancellationToken): ProviderResult<SemanticTokens>;
+    getLegend(): SemanticTokensLegend;
+    releaseDocumentSemanticTokens(resultId: string | undefined): void;
+}

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

@@ -0,0 +1,55 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { 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';
+
+let PromptDocumentSemanticTokensProvider = class PromptDocumentSemanticTokensProvider {
+    constructor(promptsService) {
+        this.promptsService = promptsService;
+        this._debugDisplayName = 'PromptDocumentSemanticTokensProvider';
+    }
+    provideDocumentSemanticTokens(model, lastResultId, token) {
+        const promptType = getPromptsTypeForLanguageId(model.getLanguageId());
+        if (!promptType) {
+            return undefined;
+        }
+        const parser = this.promptsService.getParsedPromptFile(model);
+        if (!parser.body) {
+            return undefined;
+        }
+        const variableReferences = parser.body.variableReferences;
+        if (!variableReferences.length) {
+            return undefined;
+        }
+        const data = [];
+        let lastLine = 0;
+        let lastChar = 0;
+        const ordered = [...variableReferences].sort((a, b) => a.range.startLineNumber === b.range.startLineNumber
+            ? a.range.startColumn - b.range.startColumn
+            : a.range.startLineNumber - b.range.startLineNumber);
+        for (const ref of ordered) {
+            const line = ref.range.startLineNumber - 1;
+            const char = ref.range.startColumn - 2;
+            const length = ref.range.endColumn - ref.range.startColumn + 1;
+            const deltaLine = line - lastLine;
+            const deltaChar = deltaLine === 0 ? char - lastChar : char;
+            data.push(deltaLine, deltaChar, length, 0 , 0 );
+            lastLine = line;
+            lastChar = char;
+            if (token.isCancellationRequested) {
+                break;
+            }
+        }
+        return { data: ( new Uint32Array(data)) };
+    }
+    getLegend() {
+        return { tokenTypes: ['variable'], tokenModifiers: [] };
+    }
+    releaseDocumentSemanticTokens(resultId) {
+    }
+};
+PromptDocumentSemanticTokensProvider = ( __decorate([
+    ( __param(0, IPromptsService))
+], PromptDocumentSemanticTokensProvider));
+
+export { PromptDocumentSemanticTokensProvider };

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

@@ -1,16 +1,13 @@
 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 { CompletionContext, CompletionItemProvider, CompletionList } 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 { 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 {
+export declare class PromptHeaderAutocompletion implements CompletionItemProvider {
     private readonly promptsService;
-    private readonly languageService;
     private readonly languageModelsService;
     private readonly languageModelToolsService;
     private readonly chatModeService;
@@ -22,7 +19,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, chatModeService: IChatModeService);
+    constructor(promptsService: IPromptsService, languageModelsService: ILanguageModelsService, languageModelToolsService: ILanguageModelToolsService, chatModeService: IChatModeService);
     /**
      * The main function of this provider that calculates
      * completion items based on the provided arguments.
@@ -30,7 +27,6 @@ export declare class PromptHeaderAutocompletion extends Disposable implements Co
     provideCompletionItems(model: ITextModel, position: Position, context: CompletionContext, token: CancellationToken): Promise<CompletionList | undefined>;
     private providePropertyCompletions;
     private provideValueCompletions;
-    private getSupportedProperties;
     private removeUsedProperties;
     private getValueSuggestions;
     private getModelNames;