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

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/parsers/promptVariableParser.js

@@ -0,0 +1,149 @@
+
+import { __decorate } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { BaseToken } from '../base/baseToken.js';
+import { PromptVariable, PromptVariableWithData } from '../tokens/promptVariable.js';
+import { At } from '../base/simpleCodec/tokens/at.js';
+import { Tab } from '../base/simpleCodec/tokens/tab.js';
+import { Hash } from '../base/simpleCodec/tokens/hash.js';
+import { Space } from '../base/simpleCodec/tokens/space.js';
+import { Colon } from '../base/simpleCodec/tokens/colon.js';
+import { NewLine } from '../base/linesCodec/tokens/newLine.js';
+import { FormFeed } from '../base/simpleCodec/tokens/formFeed.js';
+import { VerticalTab } from '../base/simpleCodec/tokens/verticalTab.js';
+import { CarriageReturn } from '../base/linesCodec/tokens/carriageReturn.js';
+import { ExclamationMark } from '../base/simpleCodec/tokens/exclamationMark.js';
+import { LeftBracket, RightBracket } from '../base/simpleCodec/tokens/brackets.js';
+import { LeftAngleBracket, RightAngleBracket } from '../base/simpleCodec/tokens/angleBrackets.js';
+import { ParserBase, assertNotConsumed } from '../base/simpleCodec/parserBase.js';
+
+const STOP_CHARACTERS = ( [Space, Tab, NewLine, CarriageReturn, VerticalTab, FormFeed, Hash, At]
+    .map((token) => { return token.symbol; }));
+const INVALID_NAME_CHARACTERS = ( [Hash, Colon, ExclamationMark, LeftAngleBracket, RightAngleBracket, LeftBracket, RightBracket]
+    .map((token) => { return token.symbol; }));
+class PartialPromptVariableName extends ParserBase {
+    constructor(token) {
+        super([token]);
+    }
+    accept(token) {
+        if (STOP_CHARACTERS.includes(token.text)) {
+            try {
+                return {
+                    result: 'success',
+                    nextParser: this.asPromptVariable(),
+                    wasTokenConsumed: false,
+                };
+            }
+            catch (error) {
+                return {
+                    result: 'failure',
+                    wasTokenConsumed: false,
+                };
+            }
+            finally {
+                this.isConsumed = true;
+            }
+        }
+        if (token instanceof Colon) {
+            this.isConsumed = true;
+            if (this.currentTokens.length <= 1) {
+                return {
+                    result: 'failure',
+                    wasTokenConsumed: false,
+                };
+            }
+            return {
+                result: 'success',
+                nextParser: ( new PartialPromptVariableWithData([...this.currentTokens, token])),
+                wasTokenConsumed: true,
+            };
+        }
+        if (INVALID_NAME_CHARACTERS.includes(token.text)) {
+            this.isConsumed = true;
+            return {
+                result: 'failure',
+                wasTokenConsumed: false,
+            };
+        }
+        this.currentTokens.push(token);
+        return {
+            result: 'success',
+            nextParser: this,
+            wasTokenConsumed: true,
+        };
+    }
+    asPromptVariable() {
+        assert(this.currentTokens.length > 1, 'Cannot create a prompt variable out of incomplete token sequence.');
+        const firstToken = this.currentTokens[0];
+        const lastToken = this.currentTokens[this.currentTokens.length - 1];
+        const variableNameTokens = this.currentTokens.slice(1);
+        const variableName = BaseToken.render(variableNameTokens);
+        return ( new PromptVariable(( new Range(
+            firstToken.range.startLineNumber,
+            firstToken.range.startColumn,
+            lastToken.range.endLineNumber,
+            lastToken.range.endColumn
+        )), variableName));
+    }
+}
+PartialPromptVariableName.__decorator = ( __decorate([
+    assertNotConsumed
+], PartialPromptVariableName.prototype, "accept", null));
+class PartialPromptVariableWithData extends ParserBase {
+    constructor(tokens) {
+        const firstToken = tokens[0];
+        const lastToken = tokens[tokens.length - 1];
+        assert(tokens.length > 2, `Tokens list must contain at least 3 items, got '${tokens.length}'.`);
+        assert(firstToken instanceof Hash, `The first token must be a '#', got '${firstToken} '.`);
+        assert(lastToken instanceof Colon, `The last token must be a ':', got '${lastToken} '.`);
+        super([...tokens]);
+    }
+    accept(token) {
+        if (STOP_CHARACTERS.includes(token.text)) {
+            this.isConsumed = true;
+            const firstToken = this.currentTokens[0];
+            const lastToken = this.currentTokens[this.currentTokens.length - 1];
+            const variableNameTokens = this.currentTokens.slice(1, this.startTokensCount - 1);
+            const variableDataTokens = this.currentTokens.slice(this.startTokensCount);
+            const fullRange = ( new Range(
+                firstToken.range.startLineNumber,
+                firstToken.range.startColumn,
+                lastToken.range.endLineNumber,
+                lastToken.range.endColumn
+            ));
+            const variableName = BaseToken.render(variableNameTokens);
+            const variableData = BaseToken.render(variableDataTokens);
+            return {
+                result: 'success',
+                nextParser: ( new PromptVariableWithData(fullRange, variableName, variableData)),
+                wasTokenConsumed: false,
+            };
+        }
+        this.currentTokens.push(token);
+        return {
+            result: 'success',
+            nextParser: this,
+            wasTokenConsumed: true,
+        };
+    }
+    asPromptVariableWithData() {
+        const variableNameTokens = this.currentTokens.slice(1, this.startTokensCount - 1);
+        const variableDataTokens = this.currentTokens.slice(this.startTokensCount);
+        const variableName = BaseToken.render(variableNameTokens);
+        const variableData = BaseToken.render(variableDataTokens);
+        const firstToken = this.currentTokens[0];
+        const lastToken = this.currentTokens[this.currentTokens.length - 1];
+        return ( new PromptVariableWithData(( new Range(
+            firstToken.range.startLineNumber,
+            firstToken.range.startColumn,
+            lastToken.range.endLineNumber,
+            lastToken.range.endColumn
+        )), variableName, variableData));
+    }
+}
+PartialPromptVariableWithData.__decorator = ( __decorate([
+    assertNotConsumed
+], PartialPromptVariableWithData.prototype, "accept", null));
+
+export { INVALID_NAME_CHARACTERS, PartialPromptVariableName, PartialPromptVariableWithData, STOP_CHARACTERS };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/tokens/fileReference.d.ts

@@ -0,0 +1,8 @@
+import { PromptVariableWithData } from "./promptVariable.js";
+import { IRange, Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+export declare class FileReference extends PromptVariableWithData {
+    readonly path: string;
+    constructor(range: Range, path: string);
+    static from(variable: PromptVariableWithData): FileReference;
+    get linkRange(): IRange | undefined;
+}

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/tokens/fileReference.js

@@ -0,0 +1,20 @@
+
+import { PromptVariableWithData } from './promptVariable.js';
+import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+
+const VARIABLE_NAME = 'file';
+class FileReference extends PromptVariableWithData {
+    constructor(range, path) {
+        super(range, VARIABLE_NAME, path);
+        this.path = path;
+    }
+    static from(variable) {
+        assert(variable.name === VARIABLE_NAME, `Variable name must be '${VARIABLE_NAME}', got '${variable.name}'.`);
+        return ( new FileReference(variable.range, variable.data));
+    }
+    get linkRange() {
+        return super.dataRange;
+    }
+}
+
+export { FileReference };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/tokens/promptAtMention.d.ts

@@ -0,0 +1,8 @@
+import { PromptToken } from "./promptToken.js";
+import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+export declare class PromptAtMention extends PromptToken {
+    readonly name: string;
+    constructor(range: Range, name: string);
+    get text(): string;
+    toString(): string;
+}

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/tokens/promptAtMention.js

@@ -0,0 +1,25 @@
+
+import { PromptToken } from './promptToken.js';
+import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { INVALID_NAME_CHARACTERS, STOP_CHARACTERS } from '../parsers/promptVariableParser.js';
+
+const START_CHARACTER = '@';
+class PromptAtMention extends PromptToken {
+    constructor(range,
+    name) {
+        for (const character of name) {
+            assert((INVALID_NAME_CHARACTERS.includes(character) === false) &&
+                (STOP_CHARACTERS.includes(character) === false), `Mention 'name' cannot contain character '${character}', got '${name}'.`);
+        }
+        super(range);
+        this.name = name;
+    }
+    get text() {
+        return `${START_CHARACTER}${this.name}`;
+    }
+    toString() {
+        return `${this.text}${this.range}`;
+    }
+}
+
+export { PromptAtMention };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/tokens/promptSlashCommand.d.ts

@@ -0,0 +1,8 @@
+import { PromptToken } from "./promptToken.js";
+import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+export declare class PromptSlashCommand extends PromptToken {
+    readonly name: string;
+    constructor(range: Range, name: string);
+    get text(): string;
+    toString(): string;
+}

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/tokens/promptSlashCommand.js

@@ -0,0 +1,19 @@
+
+import { PromptToken } from './promptToken.js';
+
+const START_CHARACTER = '/';
+class PromptSlashCommand extends PromptToken {
+    constructor(range,
+    name) {
+        super(range);
+        this.name = name;
+    }
+    get text() {
+        return `${START_CHARACTER}${this.name}`;
+    }
+    toString() {
+        return `${this.text}${this.range}`;
+    }
+}
+
+export { PromptSlashCommand };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/tokens/promptTemplateVariable.d.ts

@@ -0,0 +1,8 @@
+import { PromptToken } from "./promptToken.js";
+import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+export declare class PromptTemplateVariable extends PromptToken {
+    readonly contents: string;
+    constructor(range: Range, contents: string);
+    get text(): string;
+    toString(): string;
+}

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/tokens/promptTemplateVariable.js

@@ -0,0 +1,25 @@
+
+import { PromptToken } from './promptToken.js';
+import { DollarSign } from '../base/simpleCodec/tokens/dollarSign.js';
+import { LeftCurlyBrace, RightCurlyBrace } from '../base/simpleCodec/tokens/curlyBraces.js';
+
+class PromptTemplateVariable extends PromptToken {
+    constructor(range,
+    contents) {
+        super(range);
+        this.contents = contents;
+    }
+    get text() {
+        return [
+            DollarSign.symbol,
+            LeftCurlyBrace.symbol,
+            this.contents,
+            RightCurlyBrace.symbol,
+        ].join('');
+    }
+    toString() {
+        return `${this.text}${this.range}`;
+    }
+}
+
+export { PromptTemplateVariable };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/tokens/promptToken.d.ts

@@ -0,0 +1,3 @@
+import { BaseToken } from "../base/baseToken.js";
+export declare abstract class PromptToken extends BaseToken {
+}

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/tokens/promptToken.js

@@ -0,0 +1,7 @@
+
+import { BaseToken } from '../base/baseToken.js';
+
+class PromptToken extends BaseToken {
+}
+
+export { PromptToken };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/tokens/promptVariable.d.ts

@@ -0,0 +1,14 @@
+import { PromptToken } from "./promptToken.js";
+import { IRange, Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+export declare class PromptVariable extends PromptToken {
+    readonly name: string;
+    constructor(range: Range, name: string);
+    get text(): string;
+    toString(): string;
+}
+export declare class PromptVariableWithData extends PromptVariable {
+    readonly data: string;
+    constructor(fullRange: Range, name: string, data: string);
+    get text(): string;
+    get dataRange(): IRange | undefined;
+}

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/tokens/promptVariable.js

@@ -0,0 +1,48 @@
+
+import { PromptToken } from './promptToken.js';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+
+const START_CHARACTER = '#';
+const DATA_SEPARATOR = ':';
+class PromptVariable extends PromptToken {
+    constructor(range,
+    name) {
+        super(range);
+        this.name = name;
+    }
+    get text() {
+        return `${START_CHARACTER}${this.name}`;
+    }
+    toString() {
+        return `${this.text}${this.range}`;
+    }
+}
+class PromptVariableWithData extends PromptVariable {
+    constructor(fullRange,
+    name,
+    data) {
+        super(fullRange, name);
+        this.data = data;
+    }
+    get text() {
+        return `${START_CHARACTER}${this.name}${DATA_SEPARATOR}${this.data}`;
+    }
+    get dataRange() {
+        const { range } = this;
+        const dataStartColumn = range.startColumn +
+            START_CHARACTER.length + this.name.length +
+            DATA_SEPARATOR.length;
+        const result = ( new Range(
+         range.startLineNumber,
+         dataStartColumn,
+         range.endLineNumber,
+         range.endColumn
+        ));
+        if (result.isEmpty()) {
+            return undefined;
+        }
+        return result;
+    }
+}
+
+export { PromptVariable, PromptVariableWithData };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/{contributions → config}/configMigration.js

@@ -2,9 +2,8 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
-import { asBoolean } from '@codingame/monaco-vscode-47472025-cc45-5680-86cd-09ceaba921a1-common/vscode/vs/platform/prompts/common/config';
+import { PromptsConfig, asBoolean } from '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/config';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
-import { CONFIG_KEY, PROMPT_LOCATIONS_CONFIG_KEY } from '@codingame/monaco-vscode-47472025-cc45-5680-86cd-09ceaba921a1-common/vscode/vs/platform/prompts/common/prompts';
 
 let ConfigMigration = class ConfigMigration {
     constructor(logService, configService) {
@@ -16,7 +15,7 @@ let ConfigMigration = class ConfigMigration {
         });
     }
     async migrateConfig() {
-        const value = await this.configService.getValue(CONFIG_KEY);
+        const value = await this.configService.getValue(PromptsConfig.KEY);
         if ((value === undefined) || (value === null)) {
             return;
         }
@@ -35,8 +34,8 @@ let ConfigMigration = class ConfigMigration {
                 }
                 locationsValue[trimmedValue] = true;
             }
-            await this.configService.updateValue(CONFIG_KEY, true);
-            await this.configService.updateValue(PROMPT_LOCATIONS_CONFIG_KEY, locationsValue);
+            await this.configService.updateValue(PromptsConfig.KEY, true);
+            await this.configService.updateValue(PromptsConfig.PROMPT_LOCATIONS_KEY, locationsValue);
             return;
         }
         if (typeof value === 'object') {
@@ -52,14 +51,14 @@ let ConfigMigration = class ConfigMigration {
                 }
                 locationsValue[trimmedValue] = enabled;
             }
-            await this.configService.updateValue(CONFIG_KEY, true);
-            await this.configService.updateValue(PROMPT_LOCATIONS_CONFIG_KEY, locationsValue);
+            await this.configService.updateValue(PromptsConfig.KEY, true);
+            await this.configService.updateValue(PromptsConfig.PROMPT_LOCATIONS_KEY, locationsValue);
             return;
         }
         if (typeof value === 'string') {
             assert(asBoolean(value) === undefined, `String value must not be a boolean, got '${value}'.`);
-            await this.configService.updateValue(CONFIG_KEY, true);
-            await this.configService.updateValue(PROMPT_LOCATIONS_CONFIG_KEY, { [value]: true });
+            await this.configService.updateValue(PromptsConfig.KEY, true);
+            await this.configService.updateValue(PromptsConfig.PROMPT_LOCATIONS_KEY, { [value]: true });
             return;
         }
     }

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

@@ -0,0 +1,23 @@
+import { IPromptContentsProvider } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/contentProviders/types";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { VSBufferReadableStream } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buffer";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
+import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service";
+import { IPromptContentsProviderOptions, PromptContentsProviderBase } from "./promptContentsProviderBase.js";
+import { FileChangesEvent } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+export declare class FilePromptContentProvider extends PromptContentsProviderBase<FileChangesEvent> implements IPromptContentsProvider {
+    readonly uri: URI;
+    private readonly fileService;
+    private readonly modelService;
+    private readonly languageService;
+    get sourceName(): string;
+    get languageId(): string;
+    constructor(uri: URI, options: IPromptContentsProviderOptions, fileService: IFileService, modelService: IModelService, languageService: ILanguageService);
+    protected getContentsStream(_event: FileChangesEvent | "full", cancellationToken?: CancellationToken): Promise<VSBufferReadableStream>;
+    createNew(promptContentsSource: {
+        uri: URI;
+    }, options: IPromptContentsProviderOptions): IPromptContentsProvider;
+    toString(): string;
+}

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

@@ -0,0 +1,97 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { PROMPT_LANGUAGE_ID } from '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
+import { isPromptOrInstructionsFile } from '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/promptFileLocations';
+import { PromptContentsProviderBase } from './promptContentsProviderBase.js';
+import { FolderReference, NotPromptFile, ResolveError, OpenFailed } from '../../promptFileReferenceErrors.js';
+import { FileChangeType } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+
+var FilePromptContentProvider_1;
+let FilePromptContentProvider = FilePromptContentProvider_1 = class FilePromptContentProvider extends PromptContentsProviderBase {
+    get sourceName() {
+        return 'file';
+    }
+    get languageId() {
+        if (this.options.languageId) {
+            return this.options.languageId;
+        }
+        const model = this.modelService.getModel(this.uri);
+        if (model !== null) {
+            return model.getLanguageId();
+        }
+        const inferredId = this.languageService
+            .guessLanguageIdByFilepathOrFirstLine(this.uri);
+        if (inferredId !== null) {
+            return inferredId;
+        }
+        return PROMPT_LANGUAGE_ID;
+    }
+    constructor(uri, options, fileService, modelService, languageService) {
+        super(options);
+        this.uri = uri;
+        this.fileService = fileService;
+        this.modelService = modelService;
+        this.languageService = languageService;
+        if (options.updateOnChange) {
+            this._register(this.fileService.onDidFilesChange((event) => {
+                if (event.contains(this.uri, FileChangeType.ADDED, FileChangeType.UPDATED)) {
+                    this.onChangeEmitter.fire('full');
+                    return;
+                }
+                if (event.contains(this.uri, FileChangeType.DELETED)) {
+                    this.onChangeEmitter.fire(event);
+                    return;
+                }
+            }));
+        }
+    }
+    async getContentsStream(_event, cancellationToken) {
+        assert(!cancellationToken?.isCancellationRequested, ( new CancellationError()));
+        let fileStream;
+        try {
+            const info = await this.fileService.resolve(this.uri);
+            assert(!cancellationToken?.isCancellationRequested, ( new CancellationError()));
+            assert(info.isFile, ( new FolderReference(this.uri)));
+            const { allowNonPromptFiles } = this.options;
+            if ((allowNonPromptFiles !== true) && (isPromptOrInstructionsFile(this.uri) === false)) {
+                throw ( new NotPromptFile(this.uri));
+            }
+            fileStream = await this.fileService.readFileStream(this.uri);
+            if (this.isDisposed || cancellationToken?.isCancellationRequested) {
+                fileStream.value.destroy();
+                throw ( new CancellationError());
+            }
+            return fileStream.value;
+        }
+        catch (error) {
+            if ((error instanceof ResolveError) || (error instanceof CancellationError)) {
+                throw error;
+            }
+            throw ( new OpenFailed(this.uri, error));
+        }
+    }
+    createNew(promptContentsSource, options) {
+        return ( new FilePromptContentProvider_1(
+            promptContentsSource.uri,
+            options,
+            this.fileService,
+            this.modelService,
+            this.languageService
+        ));
+    }
+    toString() {
+        return `file-prompt-contents-provider:${this.uri.path}`;
+    }
+};
+FilePromptContentProvider = FilePromptContentProvider_1 = ( __decorate([
+    ( __param(2, IFileService)),
+    ( __param(3, IModelService)),
+    ( __param(4, ILanguageService))
+], FilePromptContentProvider));
+
+export { FilePromptContentProvider };

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

@@ -0,0 +1,32 @@
+import { VSBufferReadableStream } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buffer";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Emitter } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ResolveError } from "../../promptFileReferenceErrors.js";
+import { PromptsType } from "@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-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";
+export interface IPromptContentsProviderOptions {
+    readonly allowNonPromptFiles: boolean;
+    readonly languageId: string | undefined;
+    readonly updateOnChange: boolean;
+}
+export declare abstract class PromptContentsProviderBase<TChangeEvent extends NonNullable<unknown>> extends ObservableDisposable implements IPromptContentsProvider {
+    abstract readonly uri: URI;
+    abstract createNew(promptContentsSource: {
+        uri: URI;
+    }, options: IPromptContentsProviderOptions): IPromptContentsProvider;
+    abstract toString(): string;
+    abstract get languageId(): string;
+    abstract get sourceName(): string;
+    get contents(): Promise<VSBufferReadableStream>;
+    get promptType(): PromptsType | "non-prompt";
+    protected abstract getContentsStream(changesEvent: TChangeEvent | "full", cancellationToken?: CancellationToken): Promise<VSBufferReadableStream>;
+    protected readonly onChangeEmitter: Emitter<"full" | TChangeEvent>;
+    protected readonly options: IPromptContentsProviderOptions;
+    constructor(options: IPromptContentsProviderOptions);
+    private readonly onContentChangedEmitter;
+    readonly onContentChanged: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<VSBufferReadableStream | ResolveError>;
+    private onContentsChanged;
+    start(token?: CancellationToken): this;
+}

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

@@ -0,0 +1,67 @@
+
+import { __decorate } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { cancelPreviousCalls } from '../../../../../../base/common/decorators/cancelPreviousCalls.js';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { ResolveError, FailedToResolveContentsStream } from '../../promptFileReferenceErrors.js';
+import { PROMPT_LANGUAGE_ID, PromptsType, INSTRUCTIONS_LANGUAGE_ID, MODE_LANGUAGE_ID } from '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { ObservableDisposable } from '../utils/observableDisposable.js';
+
+class PromptContentsProviderBase extends ObservableDisposable {
+    get contents() {
+        return this.getContentsStream('full');
+    }
+    get promptType() {
+        const { languageId } = this;
+        if (languageId === PROMPT_LANGUAGE_ID) {
+            return PromptsType.prompt;
+        }
+        if (languageId === INSTRUCTIONS_LANGUAGE_ID) {
+            return PromptsType.instructions;
+        }
+        if (languageId === MODE_LANGUAGE_ID) {
+            return PromptsType.mode;
+        }
+        return 'non-prompt';
+    }
+    constructor(options) {
+        super();
+        this.onChangeEmitter = this._register(( new Emitter()));
+        this.onContentChangedEmitter = this._register(( new Emitter()));
+        this.onContentChanged = this.onContentChangedEmitter.event;
+        this.options = options;
+    }
+    onContentsChanged(event, cancellationToken) {
+        const promise = (cancellationToken?.isCancellationRequested)
+            ? Promise.reject(( new CancellationError()))
+            : this.getContentsStream(event, cancellationToken);
+        promise
+            .then((stream) => {
+            if (cancellationToken?.isCancellationRequested || this.isDisposed) {
+                stream.destroy();
+                throw ( new CancellationError());
+            }
+            this.onContentChangedEmitter.fire(stream);
+        })
+            .catch((error) => {
+            if (error instanceof ResolveError) {
+                this.onContentChangedEmitter.fire(error);
+                return;
+            }
+            this.onContentChangedEmitter.fire(( new FailedToResolveContentsStream(this.uri, error)));
+        });
+        return this;
+    }
+    start(token) {
+        assert(!this.isDisposed, 'Cannot start contents provider that was already disposed.');
+        this.onContentsChanged('full', token);
+        this._register(this.onChangeEmitter.event(this.onContentsChanged, this));
+        return this;
+    }
+}
+PromptContentsProviderBase.__decorator = ( __decorate([
+    cancelPreviousCalls
+], PromptContentsProviderBase.prototype, "onContentsChanged", null));
+
+export { PromptContentsProviderBase };

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

@@ -0,0 +1,22 @@
+import { VSBufferReadableStream } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buffer";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { TextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model/textModel";
+import { IModelContentChangedEvent } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/textModelEvents";
+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";
+export declare class TextModelContentsProvider extends PromptContentsProviderBase<IModelContentChangedEvent> {
+    private readonly model;
+    private readonly instantiationService;
+    get uri(): URI;
+    get sourceName(): string;
+    get languageId(): string;
+    constructor(model: ITextModel, options: IPromptContentsProviderOptions, instantiationService: IInstantiationService);
+    protected getContentsStream(_event: IModelContentChangedEvent | "full", cancellationToken?: CancellationToken): Promise<VSBufferReadableStream>;
+    createNew(promptContentsSource: TextModel | {
+        uri: URI;
+    }, options: IPromptContentsProviderOptions): IPromptContentsProvider;
+    toString(): string;
+}