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

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/utils/objectStream.d.ts

@@ -0,0 +1,25 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { ObservableDisposable } from "../../../utils/observableDisposable.js";
+import { ReadableStream } from "@codingame/monaco-vscode-api/vscode/vs/base/common/stream";
+export declare class ObjectStream<T extends object> extends ObservableDisposable implements ReadableStream<T> {
+    private readonly data;
+    private readonly cancellationToken?;
+    private ended;
+    private readonly stream;
+    private timeoutHandle;
+    constructor(data: Generator<T, undefined>, cancellationToken?: CancellationToken | undefined);
+    send(stopAfterFirstSend?: boolean): void;
+    stopStream(): this;
+    private sendData;
+    private end;
+    pause(): void;
+    resume(): void;
+    destroy(): void;
+    removeListener(event: string, callback: (...args: any[]) => void): void;
+    on(event: "data", callback: (data: T) => void): void;
+    on(event: "error", callback: (err: Error) => void): void;
+    on(event: "end", callback: () => void): void;
+    dispose(): void;
+    static fromArray<T extends object>(array: T[], cancellationToken?: CancellationToken): ObjectStream<T>;
+}
+export declare function arrayToGenerator<T extends NonNullable<unknown>>(array: T[]): Generator<T, undefined>;

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/utils/objectStream.js

@@ -0,0 +1,126 @@
+
+import { assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { ObservableDisposable } from '../../../utils/observableDisposable.js';
+import { newWriteableStream } from '@codingame/monaco-vscode-api/vscode/vs/base/common/stream';
+
+class ObjectStream extends ObservableDisposable {
+    constructor(data, cancellationToken) {
+        super();
+        this.data = data;
+        this.cancellationToken = cancellationToken;
+        this.ended = false;
+        this.stream = newWriteableStream(null);
+        if (cancellationToken?.isCancellationRequested) {
+            this.end();
+            return;
+        }
+        this.send(true);
+    }
+    send(stopAfterFirstSend = false) {
+        if (this.cancellationToken?.isCancellationRequested || this.ended) {
+            this.end();
+            return;
+        }
+        this.sendData()
+            .then(() => {
+            if (this.cancellationToken?.isCancellationRequested || this.ended) {
+                this.end();
+                return;
+            }
+            if (stopAfterFirstSend === true) {
+                this.stopStream();
+                return;
+            }
+            this.timeoutHandle = setTimeout(this.send.bind(this));
+        })
+            .catch((error) => {
+            this.stream.error(error);
+            this.dispose();
+        });
+    }
+    stopStream() {
+        if (this.timeoutHandle === undefined) {
+            return this;
+        }
+        clearTimeout(this.timeoutHandle);
+        this.timeoutHandle = undefined;
+        return this;
+    }
+    async sendData(objectsCount = 25) {
+        while (objectsCount > 0) {
+            try {
+                const next = this.data.next();
+                if (next.done || this.cancellationToken?.isCancellationRequested) {
+                    this.end();
+                    return;
+                }
+                await this.stream.write(next.value);
+                objectsCount--;
+            }
+            catch (error) {
+                this.stream.error(error);
+                this.dispose();
+                return;
+            }
+        }
+    }
+    end() {
+        if (this.ended) {
+            return this;
+        }
+        this.ended = true;
+        this.stopStream();
+        this.stream.end();
+        return this;
+    }
+    pause() {
+        this.stopStream();
+        this.stream.pause();
+        return;
+    }
+    resume() {
+        this.send();
+        this.stream.resume();
+        return;
+    }
+    destroy() {
+        this.dispose();
+    }
+    removeListener(event, callback) {
+        this.stream.removeListener(event, callback);
+        return;
+    }
+    on(event, callback) {
+        if (event === 'data') {
+            this.stream.on(event, callback);
+            this.send();
+            return;
+        }
+        if (event === 'error') {
+            this.stream.on(event, callback);
+            return;
+        }
+        if (event === 'end') {
+            this.stream.on(event, callback);
+            return;
+        }
+        assertNever(event, `Unexpected event name '${event}'.`);
+    }
+    dispose() {
+        this.stopStream();
+        this.stream.destroy();
+        super.dispose();
+    }
+    static fromArray(array, cancellationToken) {
+        return ( new ObjectStream(arrayToGenerator(array), cancellationToken));
+    }
+}
+function arrayToGenerator(array) {
+    return (function* () {
+        for (const item of array) {
+            yield item;
+        }
+    })();
+}
+
+export { ObjectStream, arrayToGenerator };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/utils/objectStreamFromTextModel.d.ts

@@ -0,0 +1,5 @@
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { ObjectStream } from "./objectStream.js";
+import { VSBuffer } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buffer";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+export declare function objectStreamFromTextModel(model: ITextModel, cancellationToken?: CancellationToken): ObjectStream<VSBuffer>;

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/utils/objectStreamFromTextModel.js

@@ -0,0 +1,25 @@
+
+import { ObjectStream } from './objectStream.js';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+
+function objectStreamFromTextModel(model, cancellationToken) {
+    return ( new ObjectStream(modelToGenerator(model), cancellationToken));
+}
+function modelToGenerator(model) {
+    return (function* () {
+        const totalLines = model.getLineCount();
+        let currentLine = 1;
+        while (currentLine <= totalLines) {
+            if (model.isDisposed()) {
+                return undefined;
+            }
+            yield VSBuffer.fromString(model.getLineContent(currentLine));
+            if (currentLine !== totalLines) {
+                yield VSBuffer.fromString(model.getEOL());
+            }
+            currentLine++;
+        }
+    })();
+}
+
+export { objectStreamFromTextModel };

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

@@ -0,0 +1,12 @@
+import { VSBuffer } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buffer";
+import { ReadableStream } from "@codingame/monaco-vscode-api/vscode/vs/base/common/stream";
+import { ChatPromptDecoder, TChatPromptToken } from "./chatPromptDecoder.js";
+export interface ICodec<T, K> {
+    encode: (value: ReadableStream<K>) => ReadableStream<T>;
+    decode: (value: ReadableStream<T>) => ReadableStream<K>;
+}
+interface IChatPromptCodec extends ICodec<VSBuffer, TChatPromptToken> {
+    decode: (value: ReadableStream<VSBuffer>) => ChatPromptDecoder;
+}
+export declare const ChatPromptCodec: IChatPromptCodec;
+export {};

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

@@ -0,0 +1,13 @@
+
+import { ChatPromptDecoder } from './chatPromptDecoder.js';
+
+const ChatPromptCodec = ( Object.freeze({
+    encode: (_stream) => {
+        throw ( new Error('The `encode` method is not implemented.'));
+    },
+    decode: (stream) => {
+        return ( new ChatPromptDecoder(stream));
+    },
+}));
+
+export { ChatPromptCodec };

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

@@ -0,0 +1,16 @@
+import { PromptAtMention } from "./tokens/promptAtMention.js";
+import { VSBuffer } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buffer";
+import { PromptSlashCommand } from "./tokens/promptSlashCommand.js";
+import { ReadableStream } from "@codingame/monaco-vscode-api/vscode/vs/base/common/stream";
+import { PromptTemplateVariable } from "./tokens/promptTemplateVariable.js";
+import { BaseDecoder } from "./base/baseDecoder.js";
+import { PromptVariable, PromptVariableWithData } from "./tokens/promptVariable.js";
+import { TMarkdownToken } from "./base/markdownCodec/markdownDecoder.js";
+export type TChatPromptToken = TMarkdownToken | (PromptVariable | PromptVariableWithData) | PromptAtMention | PromptSlashCommand | PromptTemplateVariable;
+export declare class ChatPromptDecoder extends BaseDecoder<TChatPromptToken, TMarkdownToken> {
+    private current?;
+    constructor(stream: ReadableStream<VSBuffer>);
+    protected onStreamData(token: TMarkdownToken): void;
+    protected onStreamEnd(): void;
+    protected reEmitCurrentTokens(): void;
+}

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

@@ -0,0 +1,109 @@
+
+import { PromptToken } from './tokens/promptToken.js';
+import { PartialPromptAtMention } from './parsers/promptAtMentionParser.js';
+import { assert, assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { PartialPromptSlashCommand } from './parsers/promptSlashCommandParser.js';
+import { BaseDecoder } from './base/baseDecoder.js';
+import { At } from './base/simpleCodec/tokens/at.js';
+import { Hash } from './base/simpleCodec/tokens/hash.js';
+import { Slash } from './base/simpleCodec/tokens/slash.js';
+import { DollarSign } from './base/simpleCodec/tokens/dollarSign.js';
+import { PartialPromptVariableName, PartialPromptVariableWithData } from './parsers/promptVariableParser.js';
+import { MarkdownDecoder } from './base/markdownCodec/markdownDecoder.js';
+import { PartialPromptTemplateVariableStart, PartialPromptTemplateVariable } from './parsers/promptTemplateVariableParser.js';
+
+class ChatPromptDecoder extends BaseDecoder {
+    constructor(stream) {
+        super(( new MarkdownDecoder(stream)));
+    }
+    onStreamData(token) {
+        if ((token instanceof Hash) && !this.current) {
+            this.current = ( new PartialPromptVariableName(token));
+            return;
+        }
+        if ((token instanceof At) && !this.current) {
+            this.current = ( new PartialPromptAtMention(token));
+            return;
+        }
+        if ((token instanceof Slash) && !this.current) {
+            this.current = ( new PartialPromptSlashCommand(token));
+            return;
+        }
+        if ((token instanceof DollarSign) && !this.current) {
+            this.current = ( new PartialPromptTemplateVariableStart(token));
+            return;
+        }
+        if (!this.current) {
+            this._onData.fire(token);
+            return;
+        }
+        const parseResult = this.current.accept(token);
+        switch (parseResult.result) {
+            case 'success': {
+                const { nextParser } = parseResult;
+                if (nextParser instanceof PromptToken) {
+                    this._onData.fire(nextParser);
+                    delete this.current;
+                }
+                else {
+                    this.current = nextParser;
+                }
+                break;
+            }
+            case 'failure': {
+                this.reEmitCurrentTokens();
+                break;
+            }
+        }
+        if (!parseResult.wasTokenConsumed) {
+            this.onStreamData(token);
+        }
+    }
+    onStreamEnd() {
+        try {
+            if (this.current === undefined) {
+                return;
+            }
+            if (this.current instanceof PartialPromptVariableName) {
+                this._onData.fire(this.current.asPromptVariable());
+                return;
+            }
+            if (this.current instanceof PartialPromptVariableWithData) {
+                this._onData.fire(this.current.asPromptVariableWithData());
+                return;
+            }
+            if (this.current instanceof PartialPromptAtMention) {
+                this._onData.fire(this.current.asPromptAtMention());
+                return;
+            }
+            if (this.current instanceof PartialPromptSlashCommand) {
+                this._onData.fire(this.current.asPromptSlashCommand());
+                return;
+            }
+            assert((this.current instanceof PartialPromptTemplateVariableStart) === false, 'Incomplete template variable token.');
+            if (this.current instanceof PartialPromptTemplateVariable) {
+                this._onData.fire(this.current.asPromptTemplateVariable());
+                return;
+            }
+            assertNever(this.current, `Unknown parser object '${this.current}'`);
+        }
+        catch (_error) {
+            this.reEmitCurrentTokens();
+        }
+        finally {
+            delete this.current;
+            super.onStreamEnd();
+        }
+    }
+    reEmitCurrentTokens() {
+        if (this.current === undefined) {
+            return;
+        }
+        for (const token of this.current.tokens) {
+            this._onData.fire(token);
+        }
+        delete this.current;
+    }
+}
+
+export { ChatPromptDecoder };

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

@@ -0,0 +1,11 @@
+import { PromptAtMention } from "../tokens/promptAtMention.js";
+import { At } from "../base/simpleCodec/tokens/at.js";
+import { TSimpleDecoderToken } from "../base/simpleCodec/simpleDecoder.js";
+import { ParserBase, TAcceptTokenResult } from "../base/simpleCodec/parserBase.js";
+export declare const STOP_CHARACTERS: readonly string[];
+export declare const INVALID_NAME_CHARACTERS: readonly string[];
+export declare class PartialPromptAtMention extends ParserBase<TSimpleDecoderToken, PartialPromptAtMention | PromptAtMention> {
+    constructor(token: At);
+    accept(token: TSimpleDecoderToken): TAcceptTokenResult<PartialPromptAtMention | PromptAtMention>;
+    asPromptAtMention(): PromptAtMention;
+}

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

@@ -0,0 +1,80 @@
+
+import { __decorate } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { PromptAtMention } from '../tokens/promptAtMention.js';
+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 { 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, At, Colon, Hash]
+    .map((token) => { return token.symbol; }));
+const INVALID_NAME_CHARACTERS = ( [ExclamationMark, LeftAngleBracket, RightAngleBracket, LeftBracket, RightBracket]
+    .map((token) => { return token.symbol; }));
+class PartialPromptAtMention extends ParserBase {
+    constructor(token) {
+        super([token]);
+    }
+    accept(token) {
+        if (STOP_CHARACTERS.includes(token.text)) {
+            try {
+                return {
+                    result: 'success',
+                    nextParser: this.asPromptAtMention(),
+                    wasTokenConsumed: false,
+                };
+            }
+            catch (error) {
+                return {
+                    result: 'failure',
+                    wasTokenConsumed: false,
+                };
+            }
+            finally {
+                this.isConsumed = 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,
+        };
+    }
+    asPromptAtMention() {
+        assert(this.currentTokens.length > 1, 'Cannot create a prompt @mention out of incomplete token sequence.');
+        const firstToken = this.currentTokens[0];
+        const lastToken = this.currentTokens[this.currentTokens.length - 1];
+        const nameTokens = this.currentTokens.slice(1);
+        const atMentionName = BaseToken.render(nameTokens);
+        return ( new PromptAtMention(( new Range(
+            firstToken.range.startLineNumber,
+            firstToken.range.startColumn,
+            lastToken.range.endLineNumber,
+            lastToken.range.endColumn
+        )), atMentionName));
+    }
+}
+PartialPromptAtMention.__decorator = ( __decorate([
+    assertNotConsumed
+], PartialPromptAtMention.prototype, "accept", null));
+
+export { INVALID_NAME_CHARACTERS, PartialPromptAtMention, STOP_CHARACTERS };

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

@@ -0,0 +1,11 @@
+import { PromptSlashCommand } from "../tokens/promptSlashCommand.js";
+import { Slash } from "../base/simpleCodec/tokens/slash.js";
+import { TSimpleDecoderToken } from "../base/simpleCodec/simpleDecoder.js";
+import { ParserBase, TAcceptTokenResult } from "../base/simpleCodec/parserBase.js";
+export declare const STOP_CHARACTERS: readonly string[];
+export declare const INVALID_NAME_CHARACTERS: readonly string[];
+export declare class PartialPromptSlashCommand extends ParserBase<TSimpleDecoderToken, PartialPromptSlashCommand | PromptSlashCommand> {
+    constructor(token: Slash);
+    accept(token: TSimpleDecoderToken): TAcceptTokenResult<PartialPromptSlashCommand | PromptSlashCommand>;
+    asPromptSlashCommand(): PromptSlashCommand;
+}

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

@@ -0,0 +1,81 @@
+
+import { __decorate } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { PromptSlashCommand } from '../tokens/promptSlashCommand.js';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { BaseToken } from '../base/baseToken.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 { Slash } from '../base/simpleCodec/tokens/slash.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, Colon, At, Hash, Slash]
+    .map((token) => { return token.symbol; }));
+const INVALID_NAME_CHARACTERS = ( [ExclamationMark, LeftAngleBracket, RightAngleBracket, LeftBracket, RightBracket]
+    .map((token) => { return token.symbol; }));
+class PartialPromptSlashCommand extends ParserBase {
+    constructor(token) {
+        super([token]);
+    }
+    accept(token) {
+        if (STOP_CHARACTERS.includes(token.text)) {
+            try {
+                return {
+                    result: 'success',
+                    nextParser: this.asPromptSlashCommand(),
+                    wasTokenConsumed: false,
+                };
+            }
+            catch (error) {
+                return {
+                    result: 'failure',
+                    wasTokenConsumed: false,
+                };
+            }
+            finally {
+                this.isConsumed = 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,
+        };
+    }
+    asPromptSlashCommand() {
+        assert(this.currentTokens.length > 1, 'Cannot create a prompt /command out of incomplete token sequence.');
+        const firstToken = this.currentTokens[0];
+        const lastToken = this.currentTokens[this.currentTokens.length - 1];
+        const nameTokens = this.currentTokens.slice(1);
+        const atMentionName = BaseToken.render(nameTokens);
+        return ( new PromptSlashCommand(( new Range(
+            firstToken.range.startLineNumber,
+            firstToken.range.startColumn,
+            lastToken.range.endLineNumber,
+            lastToken.range.endColumn
+        )), atMentionName));
+    }
+}
+PartialPromptSlashCommand.__decorator = ( __decorate([
+    assertNotConsumed
+], PartialPromptSlashCommand.prototype, "accept", null));
+
+export { INVALID_NAME_CHARACTERS, PartialPromptSlashCommand, STOP_CHARACTERS };

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

@@ -0,0 +1,15 @@
+import { PromptTemplateVariable } from "../tokens/promptTemplateVariable.js";
+import { TSimpleDecoderToken } from "../base/simpleCodec/simpleDecoder.js";
+import { DollarSign, LeftCurlyBrace } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/simpleCodec/tokens/tokens";
+import { ParserBase, TAcceptTokenResult } from "../base/simpleCodec/parserBase.js";
+export type TPromptTemplateVariableParser = PartialPromptTemplateVariableStart | PartialPromptTemplateVariable;
+export declare class PartialPromptTemplateVariableStart extends ParserBase<DollarSign | LeftCurlyBrace, PartialPromptTemplateVariableStart | PartialPromptTemplateVariable> {
+    constructor(token: DollarSign);
+    accept(token: TSimpleDecoderToken): TAcceptTokenResult<PartialPromptTemplateVariableStart | PartialPromptTemplateVariable>;
+}
+export declare class PartialPromptTemplateVariable extends ParserBase<TSimpleDecoderToken, PartialPromptTemplateVariable | PromptTemplateVariable> {
+    constructor(tokens: (DollarSign | LeftCurlyBrace)[]);
+    accept(token: TSimpleDecoderToken): TAcceptTokenResult<PartialPromptTemplateVariable | PromptTemplateVariable>;
+    private get contents();
+    asPromptTemplateVariable(): PromptTemplateVariable;
+}

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

@@ -0,0 +1,100 @@
+
+import { __decorate } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { PromptTemplateVariable } from '../tokens/promptTemplateVariable.js';
+import { BaseToken } from '../base/baseToken.js';
+import '../base/simpleCodec/tokens/at.js';
+import '../base/simpleCodec/tokens/tab.js';
+import '../base/simpleCodec/tokens/dash.js';
+import '../base/simpleCodec/tokens/hash.js';
+import '../base/simpleCodec/tokens/colon.js';
+import '../base/simpleCodec/tokens/quote.js';
+import '../base/simpleCodec/tokens/slash.js';
+import '../base/simpleCodec/tokens/space.js';
+import '../base/simpleCodec/tokens/comma.js';
+import '../base/simpleCodec/tokens/formFeed.js';
+import { DollarSign } from '../base/simpleCodec/tokens/dollarSign.js';
+import '../base/simpleCodec/tokens/verticalTab.js';
+import '../base/simpleCodec/tokens/doubleQuote.js';
+import '../base/simpleCodec/tokens/exclamationMark.js';
+import '../base/simpleCodec/tokens/brackets.js';
+import { LeftCurlyBrace, RightCurlyBrace } from '../base/simpleCodec/tokens/curlyBraces.js';
+import '../base/simpleCodec/tokens/parentheses.js';
+import '../base/simpleCodec/tokens/angleBrackets.js';
+import { ParserBase, assertNotConsumed } from '../base/simpleCodec/parserBase.js';
+
+class PartialPromptTemplateVariableStart extends ParserBase {
+    constructor(token) {
+        super([token]);
+    }
+    accept(token) {
+        if (token instanceof LeftCurlyBrace) {
+            this.currentTokens.push(token);
+            this.isConsumed = true;
+            return {
+                result: 'success',
+                nextParser: ( new PartialPromptTemplateVariable(this.currentTokens)),
+                wasTokenConsumed: true,
+            };
+        }
+        return {
+            result: 'failure',
+            wasTokenConsumed: false,
+        };
+    }
+}
+PartialPromptTemplateVariableStart.__decorator = ( __decorate([
+    assertNotConsumed
+], PartialPromptTemplateVariableStart.prototype, "accept", null));
+class PartialPromptTemplateVariable extends ParserBase {
+    constructor(tokens) {
+        super(tokens);
+    }
+    accept(token) {
+        if (token instanceof RightCurlyBrace) {
+            this.currentTokens.push(token);
+            this.isConsumed = true;
+            return {
+                result: 'success',
+                nextParser: this.asPromptTemplateVariable(),
+                wasTokenConsumed: true,
+            };
+        }
+        this.currentTokens.push(token);
+        return {
+            result: 'success',
+            nextParser: this,
+            wasTokenConsumed: true,
+        };
+    }
+    get contents() {
+        const contentTokens = [];
+        if (this.currentTokens.length < 3) {
+            return '';
+        }
+        for (let i = 2; i < this.currentTokens.length; i++) {
+            const token = this.currentTokens[i];
+            const isLastToken = (i === this.currentTokens.length - 1);
+            if ((token instanceof RightCurlyBrace) && (isLastToken === true)) {
+                break;
+            }
+            contentTokens.push(token);
+        }
+        return BaseToken.render(contentTokens);
+    }
+    asPromptTemplateVariable() {
+        const firstToken = this.currentTokens[0];
+        const secondToken = this.currentTokens[1];
+        const lastToken = this.currentTokens[this.currentTokens.length - 1];
+        assert(this.currentTokens.length >= 3, 'Prompt template variable should have at least 3 tokens.');
+        assert(lastToken instanceof RightCurlyBrace, 'Last token is not a "}".');
+        assert(firstToken instanceof DollarSign, 'First token must be a "$".');
+        assert(secondToken instanceof LeftCurlyBrace, 'Second token must be a "{".');
+        return ( new PromptTemplateVariable(BaseToken.fullRange(this.currentTokens), this.contents));
+    }
+}
+PartialPromptTemplateVariable.__decorator = ( __decorate([
+    assertNotConsumed
+], PartialPromptTemplateVariable.prototype, "accept", null));
+
+export { PartialPromptTemplateVariable, PartialPromptTemplateVariableStart };

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

@@ -0,0 +1,16 @@
+import { PromptVariable, PromptVariableWithData } from "../tokens/promptVariable.js";
+import { Hash } from "../base/simpleCodec/tokens/hash.js";
+import { TSimpleDecoderToken } from "../base/simpleCodec/simpleDecoder.js";
+import { ParserBase, TAcceptTokenResult } from "../base/simpleCodec/parserBase.js";
+export declare const STOP_CHARACTERS: readonly string[];
+export declare const INVALID_NAME_CHARACTERS: readonly string[];
+export declare class PartialPromptVariableName extends ParserBase<TSimpleDecoderToken, PartialPromptVariableName | PartialPromptVariableWithData | PromptVariable> {
+    constructor(token: Hash);
+    accept(token: TSimpleDecoderToken): TAcceptTokenResult<PartialPromptVariableName | PartialPromptVariableWithData | PromptVariable>;
+    asPromptVariable(): PromptVariable;
+}
+export declare class PartialPromptVariableWithData extends ParserBase<TSimpleDecoderToken, PartialPromptVariableWithData | PromptVariableWithData> {
+    constructor(tokens: readonly TSimpleDecoderToken[]);
+    accept(token: TSimpleDecoderToken): TAcceptTokenResult<PartialPromptVariableWithData | PromptVariableWithData>;
+    asPromptVariableWithData(): PromptVariableWithData;
+}