@codingame/monaco-vscode-chat-service-override 18.4.0 → 19.0.0

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

@@ -0,0 +1,46 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { TextModel } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/textModel';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { objectStreamFromTextModel } from '../codecs/base/utils/objectStreamFromTextModel.js';
+import { FilePromptContentProvider } from './filePromptContentsProvider.js';
+import { PromptContentsProviderBase } from './promptContentsProviderBase.js';
+
+var TextModelContentsProvider_1;
+let TextModelContentsProvider = TextModelContentsProvider_1 = class TextModelContentsProvider extends PromptContentsProviderBase {
+    get uri() {
+        return this.model.uri;
+    }
+    get sourceName() {
+        return 'text-model';
+    }
+    get languageId() {
+        return this.options.languageId ?? this.model.getLanguageId();
+    }
+    constructor(model, options, instantiationService) {
+        super(options);
+        this.model = model;
+        this.instantiationService = instantiationService;
+        this._register(this.model.onWillDispose(this.dispose.bind(this)));
+        if (options.updateOnChange) {
+            this._register(this.model.onDidChangeContent(this.onChangeEmitter.fire.bind(this.onChangeEmitter)));
+        }
+    }
+    async getContentsStream(_event, cancellationToken) {
+        return objectStreamFromTextModel(this.model, cancellationToken);
+    }
+    createNew(promptContentsSource, options) {
+        if (promptContentsSource instanceof TextModel) {
+            return this.instantiationService.createInstance(TextModelContentsProvider_1, promptContentsSource, options);
+        }
+        return this.instantiationService.createInstance(FilePromptContentProvider, promptContentsSource.uri, options);
+    }
+    toString() {
+        return `text-model-prompt-contents-provider:${this.uri.path}`;
+    }
+};
+TextModelContentsProvider = TextModelContentsProvider_1 = ( __decorate([
+    ( __param(2, IInstantiationService))
+], TextModelContentsProvider));
+
+export { TextModelContentsProvider };

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

@@ -0,0 +1,26 @@
+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 { 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;
+    readonly _debugDisplayName: string;
+    readonly triggerCharacters: string[];
+    constructor(promptsService: IPromptsService, languageService: ILanguageFeaturesService, languageModelsService: ILanguageModelsService, languageModelToolsService: ILanguageModelToolsService);
+    provideCompletionItems(model: ITextModel, position: Position, context: CompletionContext, token: CancellationToken): Promise<CompletionList | undefined>;
+    private providePropertyCompletions;
+    private provideValueCompletions;
+    private getSupportedProperties;
+    private removeUsedProperties;
+    private getValueSuggestions;
+    private getModelNames;
+    private provideToolCompletions;
+}

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

@@ -0,0 +1,241 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CharCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/charCode';
+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 { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { CompletionItemInsertTextRule, 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 { 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 { ModeHeader } from '../parsers/promptHeader/modeHeader.js';
+import { PromptHeader } from '../parsers/promptHeader/promptHeader.js';
+import { ALL_PROMPTS_LANGUAGE_SELECTOR, getPromptsTypeForLanguageId, PromptsType } from '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-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 PromptHeaderAutocompletion = class PromptHeaderAutocompletion extends Disposable {
+    constructor(promptsService, languageService, languageModelsService, languageModelToolsService) {
+        super();
+        this.promptsService = promptsService;
+        this.languageService = languageService;
+        this.languageModelsService = languageModelsService;
+        this.languageModelToolsService = languageModelToolsService;
+        this._debugDisplayName = 'PromptHeaderAutocompletion';
+        this.triggerCharacters = [':'];
+        this._register(this.languageService.completionProvider.register(ALL_PROMPTS_LANGUAGE_SELECTOR, this));
+    }
+    async provideCompletionItems(model, position, context, 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;
+        }
+        const fullHeaderRange = parser.header.range;
+        const headerRange = ( new Range(
+            fullHeaderRange.startLineNumber + 1,
+            0,
+            fullHeaderRange.endLineNumber - 1,
+            model.getLineMaxColumn(fullHeaderRange.endLineNumber - 1)
+        ));
+        if (!headerRange.containsPosition(position)) {
+            return undefined;
+        }
+        const lineText = model.getLineContent(position.lineNumber);
+        const colonIndex = lineText.indexOf(':');
+        const colonPosition = colonIndex !== -1 ? ( new Position(position.lineNumber, colonIndex + 1)) : undefined;
+        if (!colonPosition || position.isBeforeOrEqual(colonPosition)) {
+            return this.providePropertyCompletions(model, position, headerRange, colonPosition, promptType);
+        }
+        else if (colonPosition && colonPosition.isBefore(position)) {
+            return this.provideValueCompletions(model, position, header, colonPosition, promptType);
+        }
+        return undefined;
+    }
+    async providePropertyCompletions(model, position, headerRange, colonPosition, promptType) {
+        const suggestions = [];
+        const supportedProperties = this.getSupportedProperties(promptType);
+        this.removeUsedProperties(supportedProperties, model, headerRange, position);
+        const getInsertText = (property) => {
+            if (colonPosition) {
+                return property;
+            }
+            const valueSuggestions = this.getValueSuggestions(promptType, property);
+            if (valueSuggestions.length > 0) {
+                return `${property}: \${0:${valueSuggestions[0]}}`;
+            }
+            else {
+                return `${property}: \$0`;
+            }
+        };
+        for (const property of supportedProperties) {
+            const item = {
+                label: property,
+                kind: CompletionItemKind.Property,
+                insertText: getInsertText(property),
+                insertTextRules: CompletionItemInsertTextRule.InsertAsSnippet,
+                range: ( new Range(
+                    position.lineNumber,
+                    1,
+                    position.lineNumber,
+                    !colonPosition ? model.getLineMaxColumn(position.lineNumber) : colonPosition.column
+                )),
+            };
+            suggestions.push(item);
+        }
+        return { suggestions };
+    }
+    async provideValueCompletions(model, position, header, colonPosition, promptType) {
+        const suggestions = [];
+        const lineContent = model.getLineContent(position.lineNumber);
+        const property = lineContent.substring(0, colonPosition.column - 1).trim();
+        if (!( this.getSupportedProperties(promptType).has(property))) {
+            return undefined;
+        }
+        if (header instanceof PromptHeader || header instanceof ModeHeader) {
+            const tools = header.metadataUtility.tools;
+            if (tools) {
+                const result = this.provideToolCompletions(model, position, tools);
+                if (result) {
+                    return result;
+                }
+            }
+        }
+        const bracketIndex = lineContent.indexOf('[');
+        if (bracketIndex !== -1 && bracketIndex <= position.column - 1) {
+            return undefined;
+        }
+        const whilespaceAfterColon = (lineContent.substring(colonPosition.column).match(/^\s*/)?.[0].length) ?? 0;
+        const values = this.getValueSuggestions(promptType, property);
+        for (const value of values) {
+            const item = {
+                label: value,
+                kind: CompletionItemKind.Value,
+                insertText: whilespaceAfterColon === 0 ? ` ${value}` : value,
+                range: ( new Range(
+                    position.lineNumber,
+                    colonPosition.column + whilespaceAfterColon + 1,
+                    position.lineNumber,
+                    model.getLineMaxColumn(position.lineNumber)
+                )),
+            };
+            suggestions.push(item);
+        }
+        return { suggestions };
+    }
+    getSupportedProperties(promptType) {
+        switch (promptType) {
+            case PromptsType.instructions:
+                return ( new Set(['applyTo', 'description']));
+            case PromptsType.prompt:
+                return ( new Set(['mode', 'tools', 'description', 'model']));
+            default:
+                return ( new Set(['tools', 'description', 'model']));
+        }
+    }
+    removeUsedProperties(properties, model, headerRange, position) {
+        for (let i = headerRange.startLineNumber; i <= headerRange.endLineNumber; i++) {
+            if (i !== position.lineNumber) {
+                const lineText = model.getLineContent(i);
+                const colonIndex = lineText.indexOf(':');
+                if (colonIndex !== -1) {
+                    const property = lineText.substring(0, colonIndex).trim();
+                    properties.delete(property);
+                }
+            }
+        }
+    }
+    getValueSuggestions(promptType, property) {
+        if (promptType === PromptsType.instructions && property === 'applyTo') {
+            return ['**', '**/*.ts, **/*.js', '**/*.php', '**/*.py'];
+        }
+        if (promptType === PromptsType.prompt && property === 'mode') {
+            return ['agent', 'edit', 'ask'];
+        }
+        if (property === 'tools' && (promptType === PromptsType.prompt || promptType === PromptsType.mode)) {
+            return ['[]', `['codebase', 'editFiles', 'fetch']`];
+        }
+        if (property === 'model' && (promptType === PromptsType.prompt || promptType === PromptsType.mode)) {
+            return this.getModelNames(promptType === PromptsType.mode);
+        }
+        return [];
+    }
+    getModelNames(agentModeOnly) {
+        const result = [];
+        for (const model of this.languageModelsService.getLanguageModelIds()) {
+            const metadata = this.languageModelsService.lookupLanguageModel(model);
+            if (metadata && metadata.isUserSelectable !== false) {
+                if (!agentModeOnly || ILanguageModelChatMetadata.suitableForAgentMode(metadata)) {
+                    result.push(ILanguageModelChatMetadata.asQualifiedName(metadata));
+                }
+            }
+        }
+        return result;
+    }
+    provideToolCompletions(model, position, node) {
+        const tools = node.value;
+        if (!tools || !node.range.containsPosition(position)) {
+            return undefined;
+        }
+        const getSuggestions = (toolRange) => {
+            const suggestions = [];
+            const addSuggestion = (toolName, toolRange) => {
+                let insertText;
+                if (!toolRange.isEmpty()) {
+                    const firstChar = model.getValueInRange(toolRange).charCodeAt(0);
+                    insertText = firstChar === CharCode.SingleQuote ? `'${toolName}'` : firstChar === CharCode.DoubleQuote ? `"${toolName}"` : toolName;
+                }
+                else {
+                    insertText = `'${toolName}'`;
+                }
+                suggestions.push({
+                    label: toolName,
+                    kind: CompletionItemKind.Value,
+                    filterText: insertText,
+                    insertText: insertText,
+                    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);
+            }
+            return { suggestions };
+        };
+        for (const tool of tools) {
+            const toolRange = node.getToolRange(tool);
+            if (toolRange?.containsPosition(position)) {
+                return getSuggestions(toolRange);
+            }
+        }
+        const prefix = model.getValueInRange(( new Range(position.lineNumber, 1, position.lineNumber, position.column)));
+        if (prefix.match(/[,[]\s*$/)) {
+            return getSuggestions(( new Range(position.lineNumber, position.column, position.lineNumber, position.column)));
+        }
+        return undefined;
+    }
+};
+PromptHeaderAutocompletion = ( __decorate([
+    ( __param(0, IPromptsService)),
+    ( __param(1, ILanguageFeaturesService)),
+    ( __param(2, ILanguageModelsService)),
+    ( __param(3, ILanguageModelToolsService))
+], PromptHeaderAutocompletion));
+
+export { PromptHeaderAutocompletion };

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

@@ -0,0 +1,28 @@
+import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service";
+import { ProviderInstanceBase } from "./providerInstanceBase.js";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { ProviderInstanceManagerBase, TProviderClass } from "./providerInstanceManagerBase.js";
+import { IMarkerData } from "@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers";
+import { IMarkerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers.service";
+import { PromptToolsMetadata } from "../parsers/promptHeader/metadata/tools.js";
+import { PromptModelMetadata } from "../parsers/promptHeader/metadata/model.js";
+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 { ChatModeKind } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
+declare class PromptHeaderDiagnosticsProvider extends ProviderInstanceBase {
+    private readonly markerService;
+    private readonly languageModelsService;
+    private readonly languageModelToolsService;
+    constructor(model: ITextModel, promptsService: IPromptsService, markerService: IMarkerService, languageModelsService: ILanguageModelsService, languageModelToolsService: ILanguageModelToolsService);
+    protected onPromptSettled(_error: Error | undefined, token: CancellationToken): Promise<void>;
+    validateModel(modelNode: PromptModelMetadata | undefined, modeKind: ChatModeKind | undefined, markers: IMarkerData[]): void;
+    findModelByName(languageModes: string[], modelName: string): ILanguageModelChatMetadata | undefined;
+    validateTools(tools: PromptToolsMetadata | undefined, modeKind: ChatModeKind | undefined, markers: IMarkerData[]): void;
+    toString(): string;
+}
+export declare class PromptHeaderDiagnosticsInstanceManager extends ProviderInstanceManagerBase<PromptHeaderDiagnosticsProvider> {
+    protected get InstanceClass(): TProviderClass<PromptHeaderDiagnosticsProvider>;
+}
+export {};

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

@@ -0,0 +1,155 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
+import { ProviderInstanceBase } from './providerInstanceBase.js';
+import { assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { ProviderInstanceManagerBase } from './providerInstanceManagerBase.js';
+import { PromptMetadataWarning, PromptMetadataError } from '../parsers/promptHeader/diagnostics.js';
+import { MarkerSeverity } from '@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers';
+import { IMarkerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers.service';
+import { PromptHeader } from '../parsers/promptHeader/promptHeader.js';
+import { ModeHeader } from '../parsers/promptHeader/modeHeader.js';
+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 { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+
+const MARKERS_OWNER_ID = 'prompts-header-diagnostics-provider';
+let PromptHeaderDiagnosticsProvider = class PromptHeaderDiagnosticsProvider extends ProviderInstanceBase {
+    constructor(model, promptsService, markerService, languageModelsService, languageModelToolsService) {
+        super(model, promptsService);
+        this.markerService = markerService;
+        this.languageModelsService = languageModelsService;
+        this.languageModelToolsService = languageModelToolsService;
+        this._register(languageModelsService.onDidChangeLanguageModels(() => {
+            this.onPromptSettled(undefined, CancellationToken.None);
+        }));
+        this._register(languageModelToolsService.onDidChangeTools(() => {
+            this.onPromptSettled(undefined, CancellationToken.None);
+        }));
+    }
+    async onPromptSettled(_error, token) {
+        const { header } = this.parser;
+        if (header === undefined) {
+            this.markerService.remove(MARKERS_OWNER_ID, [this.model.uri]);
+            return;
+        }
+        const completed = await header.settled;
+        if (!completed || token.isCancellationRequested) {
+            return;
+        }
+        console.log(`Prompt header diagnostics for ${( this.model.uri.toString())}:`);
+        const markers = [];
+        for (const diagnostic of header.diagnostics) {
+            markers.push(toMarker(diagnostic));
+        }
+        if (header instanceof PromptHeader) {
+            this.validateTools(header.metadataUtility.tools, header.metadata.mode, markers);
+            this.validateModel(header.metadataUtility.model, header.metadata.mode, markers);
+        }
+        else if (header instanceof ModeHeader) {
+            this.validateTools(header.metadataUtility.tools, ChatModeKind.Agent, markers);
+            this.validateModel(header.metadataUtility.model, ChatModeKind.Agent, markers);
+        }
+        if (markers.length === 0) {
+            console.warn(`No markers for ${( this.model.uri.toString())}`);
+            this.markerService.remove(MARKERS_OWNER_ID, [this.model.uri]);
+            return;
+        }
+        this.markerService.changeOne(MARKERS_OWNER_ID, this.model.uri, markers);
+        return;
+    }
+    validateModel(modelNode, modeKind, markers) {
+        if (!modelNode || modelNode.value === undefined) {
+            return;
+        }
+        const languageModes = this.languageModelsService.getLanguageModelIds();
+        if (languageModes.length === 0) {
+            return;
+        }
+        const modelMetadata = this.findModelByName(languageModes, modelNode.value);
+        if (!modelMetadata) {
+            markers.push({
+                message: ( localize(5322, "Unknown model '{0}'", modelNode.value)),
+                severity: MarkerSeverity.Warning,
+                ...modelNode.range,
+            });
+        }
+        else if (modeKind === ChatModeKind.Agent && !ILanguageModelChatMetadata.suitableForAgentMode(modelMetadata)) {
+            markers.push({
+                message: ( localize(5323, "Model '{0}' is not suited for agent mode", modelNode.value)),
+                severity: MarkerSeverity.Warning,
+                ...modelNode.range,
+            });
+        }
+    }
+    findModelByName(languageModes, modelName) {
+        for (const model of languageModes) {
+            const metadata = this.languageModelsService.lookupLanguageModel(model);
+            if (metadata && metadata.isUserSelectable !== false && ILanguageModelChatMetadata.asQualifiedName(metadata) === modelName) {
+                return metadata;
+            }
+        }
+        return undefined;
+    }
+    validateTools(tools, modeKind, markers) {
+        if (!tools || tools.value === undefined || modeKind === ChatModeKind.Ask || modeKind === ChatModeKind.Edit) {
+            return;
+        }
+        const toolNames = ( new Set(tools.value));
+        if (toolNames.size === 0) {
+            return;
+        }
+        for (const tool of this.languageModelToolsService.getTools()) {
+            toolNames.delete(tool.toolReferenceName ?? tool.displayName);
+        }
+        for (const toolSet of this.languageModelToolsService.toolSets.get()) {
+            toolNames.delete(toolSet.referenceName);
+        }
+        for (const toolName of toolNames) {
+            const range = tools.getToolRange(toolName);
+            if (range) {
+                markers.push({
+                    message: ( localize(5324, "Unknown tool '{0}'", toolName)),
+                    severity: MarkerSeverity.Warning,
+                    ...range,
+                });
+            }
+        }
+    }
+    toString() {
+        return `prompt-header-diagnostics:${this.model.uri.path}`;
+    }
+};
+PromptHeaderDiagnosticsProvider = ( __decorate([
+    ( __param(1, IPromptsService)),
+    ( __param(2, IMarkerService)),
+    ( __param(3, ILanguageModelsService)),
+    ( __param(4, ILanguageModelToolsService))
+], PromptHeaderDiagnosticsProvider));
+function toMarker(diagnostic) {
+    if (diagnostic instanceof PromptMetadataWarning) {
+        return {
+            message: diagnostic.message,
+            severity: MarkerSeverity.Warning,
+            ...diagnostic.range,
+        };
+    }
+    if (diagnostic instanceof PromptMetadataError) {
+        return {
+            message: diagnostic.message,
+            severity: MarkerSeverity.Error,
+            ...diagnostic.range,
+        };
+    }
+    assertNever(diagnostic, `Unknown prompt metadata diagnostic type '${diagnostic}'.`);
+}
+class PromptHeaderDiagnosticsInstanceManager extends ProviderInstanceManagerBase {
+    get InstanceClass() {
+        return PromptHeaderDiagnosticsProvider;
+    }
+}
+
+export { PromptHeaderDiagnosticsInstanceManager };

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

@@ -0,0 +1,22 @@
+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 { Hover, HoverContext, HoverProvider } 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 { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service";
+export declare class PromptHeaderHoverProvider extends Disposable implements HoverProvider {
+    private readonly promptsService;
+    private readonly languageService;
+    private readonly languageModelToolsService;
+    private readonly languageModelsService;
+    readonly _debugDisplayName: string;
+    constructor(promptsService: IPromptsService, languageService: ILanguageFeaturesService, languageModelToolsService: ILanguageModelToolsService, languageModelsService: ILanguageModelsService);
+    private createHover;
+    provideHover(model: ITextModel, position: Position, token: CancellationToken, _context?: HoverContext): Promise<Hover | undefined>;
+    private getToolHover;
+    private getToolsetHover;
+    private getModelHover;
+}