@codingame/monaco-vscode-chat-service-override 20.1.1 → 20.2.0

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/contentProviders/promptContentsProviderBase.d.ts

@@ -6,11 +6,38 @@ import { ResolveError } from "../../promptFileReferenceErrors.js";
 import { PromptsType } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
 import { ObservableDisposable } from "../utils/observableDisposable.js";
 import { IPromptContentsProvider } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/contentProviders/types";
+/**
+ * Options of the {@link PromptContentsProviderBase} class.
+ */
 export interface IPromptContentsProviderOptions {
+    /**
+     * Whether to allow files that don't have usual prompt
+     * file extension to be treated as a prompt file.
+     */
     readonly allowNonPromptFiles: boolean;
+    /**
+     * Language ID to use for the prompt contents. If not set, the language ID will be inferred from the file.
+     */
     readonly languageId: string | undefined;
+    /**
+     * If set to `true`, the contents provider will listen for updates and retrigger a parse.
+     */
     readonly updateOnChange: boolean;
 }
+/**
+ * Base class for prompt contents providers. Classes that extend this one are responsible to:
+ *
+ * - implement the {@link getContentsStream} method to provide the contents stream
+ *   of a prompt; this method should throw a `ResolveError` or its derivative if the contents
+ *   cannot be parsed for any reason
+ * - fire a {@link TChangeEvent} event on the {@link onChangeEmitter} event when
+ * 	 prompt contents change
+ * - misc:
+ *   - provide the {@link uri} property that represents the URI of a prompt that
+ *     the contents are for
+ *   - implement the {@link toString} method to return a string representation of this
+ *     provider type to aid with debugging/tracing
+ */
 export declare abstract class PromptContentsProviderBase<TChangeEvent extends NonNullable<unknown>> extends ObservableDisposable implements IPromptContentsProvider {
     abstract readonly uri: URI;
     abstract createNew(promptContentsSource: {
@@ -19,14 +46,57 @@ export declare abstract class PromptContentsProviderBase<TChangeEvent extends No
     abstract toString(): string;
     abstract get languageId(): string;
     abstract get sourceName(): string;
+    /**
+     * Prompt contents stream.
+     */
     get contents(): Promise<VSBufferReadableStream>;
+    /**
+     * Prompt type used to determine how to interpret file contents.
+     */
     get promptType(): PromptsType | "non-prompt";
+    /**
+     * Function to get contents stream for the provider. This function should
+     * throw a `ResolveError` or its derivative if the contents cannot be parsed.
+     *
+     * @param changesEvent The event that triggered the change. The special
+     * `'full'` value means  that everything has changed hence entire prompt
+     * contents need to be re-parsed from scratch.
+     */
     protected abstract getContentsStream(changesEvent: TChangeEvent | "full", cancellationToken?: CancellationToken): Promise<VSBufferReadableStream>;
+    /**
+     * Internal event emitter for the prompt contents change event. Classes that extend
+     * this abstract class are responsible to use this emitter to fire the contents change
+     * event when the prompt contents get modified.
+     */
     protected readonly onChangeEmitter: Emitter<"full" | TChangeEvent>;
+    /**
+     * Options passed to the constructor
+     */
     protected readonly options: IPromptContentsProviderOptions;
     constructor(options: IPromptContentsProviderOptions);
+    /**
+     * Event emitter for the prompt contents change event.
+     * See {@link onContentChanged} for more details.
+     */
     private readonly onContentChangedEmitter;
+    /**
+     * Event that fires when the prompt contents change. The event is either
+     * a `VSBufferReadableStream` stream with changed contents or an instance of
+     * the `ResolveError` class representing a parsing failure case.
+     *
+     * `Note!` this field is meant to be used by the external consumers of the prompt
+     *         contents provider that the classes that extend this abstract class.
+     *         Please use the {@link onChangeEmitter} event to provide a change
+     *         event in your prompt contents implementation instead.
+     */
     readonly onContentChanged: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<VSBufferReadableStream | ResolveError>;
+    /**
+     * Internal common implementation of the event that should be fired when
+     * prompt contents change.
+     */
     private onContentsChanged;
+    /**
+     * Start producing the prompt contents data.
+     */
     start(token?: CancellationToken): this;
 }

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

@@ -7,16 +7,36 @@ import { IModelContentChangedEvent } from "@codingame/monaco-vscode-api/vscode/v
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { IPromptContentsProviderOptions, PromptContentsProviderBase } from "./promptContentsProviderBase.js";
 import { IPromptContentsProvider } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/contentProviders/types";
+/**
+ * Prompt contents provider for a {@link ITextModel} instance.
+ */
 export declare class TextModelContentsProvider extends PromptContentsProviderBase<IModelContentChangedEvent> {
     private readonly model;
     private readonly instantiationService;
+    /**
+     * URI component of the prompt associated with this contents provider.
+     */
     get uri(): URI;
     get sourceName(): string;
     get languageId(): string;
     constructor(model: ITextModel, options: IPromptContentsProviderOptions, instantiationService: IInstantiationService);
+    /**
+     * Creates a stream of binary data from the text model based on the changes
+     * listed in the provided event.
+     *
+     * Note! this method implements a basic logic which does not take into account
+     * 		 the `_event` argument for incremental updates. This needs to be improved.
+     *
+     * @param _event - event that describes the changes in the text model; `'full'` is
+     * 				   the special value that means that all contents have changed
+     * @param cancellationToken - token that cancels this operation
+     */
     protected getContentsStream(_event: IModelContentChangedEvent | "full", cancellationToken?: CancellationToken): Promise<VSBufferReadableStream>;
     createNew(promptContentsSource: TextModel | {
         uri: URI;
     }, options: IPromptContentsProviderOptions): IPromptContentsProvider;
+    /**
+     * String representation of this object.
+     */
     toString(): string;
 }

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

@@ -12,9 +12,19 @@ export declare class PromptHeaderAutocompletion extends Disposable implements Co
     private readonly languageService;
     private readonly languageModelsService;
     private readonly languageModelToolsService;
+    /**
+     * Debug display name for this provider.
+     */
     readonly _debugDisplayName: string;
+    /**
+     * List of trigger characters handled by this provider.
+     */
     readonly triggerCharacters: string[];
     constructor(promptsService: IPromptsService, languageService: ILanguageFeaturesService, languageModelsService: ILanguageModelsService, 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 providePropertyCompletions;
     private provideValueCompletions;

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

@@ -11,17 +11,31 @@ import { ILanguageModelChatMetadata } from "@codingame/monaco-vscode-api/vscode/
 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";
+/**
+ * Prompt header diagnostics provider for an individual text model
+ * of a prompt file.
+ */
 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);
+    /**
+     * Update diagnostic markers for the current editor.
+     */
     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;
+    /**
+     * Returns a string representation of this object.
+     */
     toString(): string;
 }
+/**
+ * The class that manages creation and disposal of {@link PromptHeaderDiagnosticsProvider}
+ * classes for each specific editor text model.
+ */
 export declare class PromptHeaderDiagnosticsInstanceManager extends ProviderInstanceManagerBase<PromptHeaderDiagnosticsProvider> {
     protected get InstanceClass(): TProviderClass<PromptHeaderDiagnosticsProvider>;
 }

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

@@ -12,6 +12,9 @@ export declare class PromptHeaderHoverProvider extends Disposable implements Hov
     private readonly languageService;
     private readonly languageModelToolsService;
     private readonly languageModelsService;
+    /**
+     * Debug display name for this provider.
+     */
     readonly _debugDisplayName: string;
     constructor(promptsService: IPromptsService, languageService: ILanguageFeaturesService, languageModelToolsService: ILanguageModelToolsService, languageModelsService: ILanguageModelsService);
     private createHover;

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

@@ -4,13 +4,26 @@ import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common
 import { ProviderInstanceManagerBase, TProviderClass } from "./providerInstanceManagerBase.js";
 import { IMarkerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers.service";
 import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+/**
+ * Prompt links diagnostics provider for a single text model.
+ */
 declare class PromptLinkDiagnosticsProvider extends ProviderInstanceBase {
     private readonly markerService;
     private readonly fileService;
     constructor(model: ITextModel, promptsService: IPromptsService, markerService: IMarkerService, fileService: IFileService);
+    /**
+     * Update diagnostic markers for the current editor.
+     */
     protected onPromptSettled(): Promise<void>;
+    /**
+     * Returns a string representation of this object.
+     */
     toString(): string;
 }
+/**
+ * The class that manages creation and disposal of {@link PromptLinkDiagnosticsProvider}
+ * classes for each specific editor text model.
+ */
 export declare class PromptLinkDiagnosticsInstanceManager extends ProviderInstanceManagerBase<PromptLinkDiagnosticsProvider> {
     protected get InstanceClass(): TProviderClass<PromptLinkDiagnosticsProvider>;
 }

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

@@ -2,8 +2,14 @@ import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbenc
 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 { ILinksList, LinkProvider } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
+/**
+ * Provides link references for prompt files.
+ */
 export declare class PromptLinkProvider implements LinkProvider {
     private readonly promptsService;
     constructor(promptsService: IPromptsService);
+    /**
+     * Provide list of links for the provided text model.
+     */
     provideLinks(model: ITextModel, token: CancellationToken): Promise<ILinksList | undefined>;
 }

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

@@ -1,3 +1,13 @@
+/**
+ * Notes on what to implement next:
+ *   - re-trigger suggestions dialog on `folder` selection because the `#file:` references take
+ *     `file` paths, therefore a "folder" completion is never final
+ *   - provide the same suggestions that the `#file:` variables in the chat input have, e.g.,
+ *     recently used files, related files, etc.
+ *   - support markdown links; markdown extension does sometimes provide the paths completions, but
+ *     the prompt completions give more options (e.g., recently used files, related files, etc.)
+ *   - add `Windows` support
+ */
 import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service";
 import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
@@ -6,17 +16,52 @@ import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/fi
 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";
+/**
+ * Type for trigger characters handled by this autocompletion provider.
+ */
 type TTriggerCharacter = ":" | "." | "/";
+/**
+ * Provides reference paths autocompletion for the `#file:` variables inside prompts.
+ */
 export declare class PromptPathAutocompletion extends Disposable implements CompletionItemProvider {
     private readonly fileService;
     private readonly promptsService;
     private readonly languageService;
+    /**
+     * Debug display name for this provider.
+     */
     readonly _debugDisplayName: string;
+    /**
+     * List of trigger characters handled by this provider.
+     */
     readonly triggerCharacters: TTriggerCharacter[];
     constructor(fileService: IFileService, promptsService: IPromptsService, languageService: ILanguageFeaturesService);
+    /**
+     * 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>;
+    /**
+     * Gets "raw" folder suggestions. Unlike the full completion items,
+     * these ones do not have `insertText` and `range` properties which
+     * are meant to be added by the caller later on.
+     */
     private getFolderSuggestions;
+    /**
+     * Gets suggestions for a first folder/file name in the path. E.g., the one
+     * that follows immediately after the `:` character of the `#file:` variable.
+     *
+     * The main difference between this and "subsequent" folder cases is that in
+     * the beginning of the path the suggestions also contain the `..` item and
+     * the `./` normalization prefix for relative paths.
+     *
+     * See also {@link getNonFirstFolderSuggestions}.
+     */
     private getFirstFolderSuggestions;
+    /**
+     * Gets suggestions for a folder/file name that follows after the first one.
+     * See also {@link getFirstFolderSuggestions}.
+     */
     private getNonFirstFolderSuggestions;
 }
 export {};

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

@@ -3,10 +3,22 @@ import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbenc
 import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
 import { ObservableDisposable } from "../utils/observableDisposable.js";
 import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+/**
+ * Abstract base class for all reusable prompt file providers.
+ */
 export declare abstract class ProviderInstanceBase extends ObservableDisposable {
     protected readonly model: ITextModel;
+    /**
+     * Function that is called when the prompt parser is settled.
+     */
     protected abstract onPromptSettled(error: Error | undefined, token: CancellationToken): Promise<void>;
+    /**
+     * Returns a string representation of this object.
+     */
     abstract toString(): string;
+    /**
+     * The prompt parser instance.
+     */
     protected readonly parser: TSharedPrompt;
     constructor(model: ITextModel, promptsService: IPromptsService);
 }

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

@@ -6,13 +6,32 @@ import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench
 import { IEditor } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/editorCommon";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+/**
+ * Type for a text editor that is used for reusable prompt files.
+ */
 export interface IPromptFileEditor extends IEditor {
     readonly getModel: () => ITextModel;
 }
+/**
+ * Type for a class that can create a new provider instance.
+ */
 export type TProviderClass<TInstance extends ProviderInstanceBase> = new (editor: ITextModel, ...args: any[]) => TInstance;
+/**
+ * A generic base class that manages creation and disposal of {@link TInstance}
+ * objects for each specific editor object that is used for reusable prompt files.
+ */
 export declare abstract class ProviderInstanceManagerBase<TInstance extends ProviderInstanceBase> extends Disposable {
+    /**
+     * Currently available {@link TInstance} instances.
+     */
     private readonly instances;
+    /**
+     * Class object of the managed {@link TInstance}.
+     */
     protected abstract get InstanceClass(): TProviderClass<TInstance>;
     constructor(modelService: IModelService, editorService: IEditorService, instantiationService: IInstantiationService, configService: IConfigurationService);
+    /**
+     * Initialize a new {@link TInstance} for the given editor.
+     */
     private handleNewEditor;
 }

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/parsers/basePromptParser.d.ts

@@ -17,56 +17,200 @@ import { OpenFailed, NotPromptFile, RecursiveReference, FolderReference, Resolve
 import { type IPromptContentsProviderOptions } from "../contentProviders/promptContentsProviderBase.js";
 import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+/**
+ * Options of the {@link BasePromptParser} class.
+ */
 export interface IBasePromptParserOptions {
 }
 export type IPromptParserOptions = IBasePromptParserOptions & IPromptContentsProviderOptions;
+/**
+ * Error conditions that may happen during the file reference resolution.
+ */
 export type TErrorCondition = OpenFailed | RecursiveReference | FolderReference | NotPromptFile;
+/**
+ * Base prompt parser class that provides a common interface for all
+ * prompt parsers that are responsible for parsing chat prompt syntax.
+ */
 export declare class BasePromptParser<TContentsProvider extends IPromptContentsProvider> extends ObservableDisposable {
     private readonly promptContentsProvider;
     protected readonly instantiationService: IInstantiationService;
     private readonly envService;
     protected readonly logService: ILogService;
+    /**
+     * Options passed to the constructor.
+     */
     protected readonly options: IBasePromptParserOptions;
+    /**
+     * List of all tokens that were parsed from the prompt contents so far.
+     */
     get tokens(): readonly BaseToken[];
+    /**
+     * Private field behind the readonly {@link tokens} property.
+     */
     private receivedTokens;
+    /**
+     * List of file references in the current branch of the file reference tree.
+     */
     private readonly _references;
+    /**
+     * Reference to the prompt header object that holds metadata associated
+     * with the prompt.
+     */
     private promptHeader?;
+    /**
+     * Reference to the prompt header object that holds metadata associated
+     * with the prompt.
+     */
     get header(): PromptHeader | InstructionsHeader | ModeHeader | undefined;
+    /**
+     * Get contents of the prompt body.
+     */
     getBody(): Promise<string>;
+    /**
+     * The event is fired when lines or their content change.
+     */
     private readonly _onUpdate;
+    /**
+     * Subscribe to the event that is fired the parser state or contents
+     * changes, including changes in the possible prompt child references.
+     */
     readonly onUpdate: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    /**
+     * Event that is fired when the current prompt parser is settled.
+     */
     private readonly _onSettled;
+    /**
+     * Event that is fired when the current prompt parser is settled.
+     */
     onSettled(callback: (error?: Error) => void): IDisposable;
+    /**
+     * If failed to parse prompt contents, this property has
+     * an error object that describes the failure reason.
+     */
     private _errorCondition?;
+    /**
+     * If file reference resolution fails, this attribute will be set
+     * to an error instance that describes the error condition.
+     */
     get errorCondition(): ResolveError | undefined;
+    /**
+     * Whether file references resolution failed.
+     * Set to `undefined` if the `resolve` method hasn't been ever called yet.
+     */
     get resolveFailed(): boolean | undefined;
+    /**
+     * The promise is resolved when at least one parse result (a stream or
+     * an error) has been received from the prompt contents provider.
+     */
     private readonly firstParseResult;
+    /**
+     * Returned promise is resolved when the parser process is settled.
+     * The settled state means that the prompt parser stream exists and
+     * has ended, or an error condition has been set in case of failure.
+     *
+     * Furthermore, this function can be called multiple times and will
+     * block until the latest prompt contents parsing logic is settled
+     * (e.g., for every `onContentChanged` event of the prompt source).
+     */
     settled(): Promise<boolean>;
     constructor(promptContentsProvider: TContentsProvider, options: IBasePromptParserOptions, instantiationService: IInstantiationService, envService: IWorkbenchEnvironmentService, logService: ILogService);
+    /**
+     * The latest received stream of prompt tokens, if any.
+     */
     private stream;
+    /**
+     * Handler the event event that is triggered when prompt contents change.
+     *
+     * @param streamOrError Either a binary stream of file contents, or an error object
+     * 						that was generated during the reference resolve attempt.
+     * @param seenReferences List of parent references that we've have already seen
+     * 					 	during the process of traversing the references tree. It's
+     * 						used to prevent the tree navigation to fall into an infinite
+     * 						references recursion.
+     */
     private onContentsChanged;
+    /**
+     * Create header object base on the target prompt file language ID.
+     * The language ID is important here, because it defines what type
+     * of metadata is valid for a prompt file and what type of related
+     * diagnostics we would show to the user.
+     */
     private createHeader;
+    /**
+     * Handle a new reference token inside prompt contents.
+     */
     private handleLinkToken;
+    /**
+     * Handle the `stream` end event.
+     *
+     * @param stream The stream that has ended.
+     * @param error Optional error object if stream ended with an error.
+     */
     private onStreamEnd;
     private disposeReferences;
+    /**
+     * Private attribute to track if the {@link start}
+     * method has been already called at least once.
+     */
     private started;
+    /**
+     * Start the prompt parser.
+     */
     start(token?: CancellationToken): this;
+    /**
+     * Associated URI of the prompt.
+     */
     get uri(): URI;
+    /**
+     * Get a list of immediate child references of the prompt.
+     */
     get references(): readonly TPromptReference[];
+    /**
+     * Valid metadata records defined in the prompt header.
+     */
     get metadata(): TMetadata | null;
+    /**
+     * The top most error of the current reference or any of its
+     * possible child reference errors.
+     */
     get topError(): ITopError | undefined;
+    /**
+     * Returns a string representation of this object.
+     */
     toString(): string;
+    /**
+     * @inheritdoc
+     */
     dispose(): void;
 }
+/**
+ * Prompt reference object represents any reference inside prompt text
+ * contents. For instance the file variable(`#file:/path/to/file.md`) or
+ * a markdown link(`[#file:file.md](/path/to/file.md)`).
+ */
 export declare class PromptReference implements TPromptReference {
     readonly uri: URI;
     readonly token: FileReference | MarkdownLink;
     constructor(uri: URI, token: FileReference | MarkdownLink);
+    /**
+     * Get the range of the `link` part of the reference.
+     */
     get linkRange(): IRange | undefined;
+    /**
+     * Type of the reference, - either a prompt `#file` variable,
+     * or a `markdown link` reference (`[caption](/path/to/file.md)`).
+     */
     get type(): "file";
+    /**
+     * Subtype of the reference, - either a prompt `#file` variable,
+     * or a `markdown link` reference (`[caption](/path/to/file.md)`).
+     */
     get subtype(): "prompt" | "markdown";
     get range(): Range;
     get path(): string;
     get text(): string;
+    /**
+     * Returns a string representation of this object.
+     */
     toString(): string;
 }

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/parsers/promptHeader/diagnostics.d.ts

@@ -1,14 +1,32 @@
 import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+/**
+ * List of all currently supported diagnostic types.
+ */
 export type TDiagnostic = PromptMetadataWarning | PromptMetadataError;
+/**
+ * Diagnostics object that hold information about some issue
+ * related to the prompt header metadata.
+ */
 export declare abstract class PromptMetadataDiagnostic {
     readonly range: Range;
     readonly message: string;
     constructor(range: Range, message: string);
+    /**
+     * String representation of the diagnostic object.
+     */
     abstract toString(): string;
 }
+/**
+ * Diagnostics object that hold information about some
+ * non-fatal issue related to the prompt header metadata.
+ */
 export declare class PromptMetadataWarning extends PromptMetadataDiagnostic {
     toString(): string;
 }
+/**
+ * Diagnostics object that hold information about some
+ * fatal issue related to the prompt header metadata.
+ */
 export declare class PromptMetadataError extends PromptMetadataDiagnostic {
     toString(): string;
 }