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

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/linesCodec/linesDecoder.js

@@ -0,0 +1,100 @@
+
+import { Line } from './tokens/line.js';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { NewLine } from './tokens/newLine.js';
+import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { CarriageReturn } from './tokens/carriageReturn.js';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { assertDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { BaseDecoder } from '../baseDecoder.js';
+
+class LinesDecoder extends BaseDecoder {
+    constructor() {
+        super(...arguments);
+        this.buffer = VSBuffer.alloc(0);
+    }
+    onStreamData(chunk) {
+        this.buffer = VSBuffer.concat([this.buffer, chunk]);
+        this.processData(false);
+    }
+    processData(streamEnded) {
+        while (this.buffer.byteLength > 0) {
+            const lineNumber = this.lastEmittedLine
+                ? this.lastEmittedLine.range.startLineNumber + 1
+                : 1;
+            const endOfLineTokens = this.findEndOfLineTokens(lineNumber, streamEnded);
+            const firstToken = endOfLineTokens[0];
+            if (firstToken === undefined) {
+                if (streamEnded) {
+                    this.emitLine(lineNumber, this.buffer.slice(0));
+                }
+                break;
+            }
+            this.emitLine(lineNumber, this.buffer.slice(0, firstToken.range.startColumn - 1));
+            assertDefined(this.lastEmittedLine, 'No last emitted line found.');
+            if ((endOfLineTokens.length === 1) && (firstToken instanceof CarriageReturn)) {
+                endOfLineTokens.splice(0, 1, ( new NewLine(firstToken.range)));
+            }
+            let startColumn = this.lastEmittedLine.range.endColumn;
+            for (const token of endOfLineTokens) {
+                const byteLength = token.byte.byteLength;
+                const endColumn = startColumn + byteLength;
+                this._onData.fire(token.withRange({ startColumn, endColumn }));
+                this.buffer = this.buffer.slice(byteLength);
+                startColumn = endColumn;
+            }
+        }
+        if (streamEnded) {
+            assert(this.buffer.byteLength === 0, 'Expected the input data buffer to be empty when the stream ends.');
+        }
+    }
+    findEndOfLineTokens(lineNumber, streamEnded) {
+        const result = [];
+        const carriageReturnIndex = this.buffer.indexOf(CarriageReturn.byte);
+        const newLineIndex = this.buffer.indexOf(NewLine.byte);
+        if (carriageReturnIndex >= 0 && ((carriageReturnIndex < newLineIndex) || (newLineIndex === -1))) {
+            result.push(( new CarriageReturn(( new Range(
+                lineNumber,
+                (carriageReturnIndex + 1),
+                lineNumber,
+                (carriageReturnIndex + 1) + CarriageReturn.byte.byteLength
+            )))));
+            if (newLineIndex === carriageReturnIndex + 1) {
+                result.push(( new NewLine(( new Range(
+                    lineNumber,
+                    (newLineIndex + 1),
+                    lineNumber,
+                    (newLineIndex + 1) + NewLine.byte.byteLength
+                )))));
+            }
+            if ((this.buffer.byteLength > carriageReturnIndex + 1) || streamEnded) {
+                return result;
+            }
+            return [];
+        }
+        if (newLineIndex >= 0) {
+            result.push(( new NewLine(( new Range(
+                lineNumber,
+                (newLineIndex + 1),
+                lineNumber,
+                (newLineIndex + 1) + NewLine.byte.byteLength
+            )))));
+        }
+        return result;
+    }
+    emitLine(lineNumber,
+    lineBytes) {
+        const line = ( new Line(lineNumber, ( lineBytes.toString())));
+        this._onData.fire(line);
+        this.lastEmittedLine = line;
+        this.buffer = this.buffer.slice(lineBytes.byteLength);
+    }
+    onStreamEnd() {
+        if (this.buffer.byteLength > 0) {
+            this.processData(true);
+        }
+        super.onStreamEnd();
+    }
+}
+
+export { LinesDecoder };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/linesCodec/tokens/carriageReturn.d.ts

@@ -0,0 +1,9 @@
+import { VSBuffer } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buffer";
+import { SimpleToken } from "../../simpleCodec/tokens/simpleToken.js";
+export declare class CarriageReturn extends SimpleToken<"\r"> {
+    static readonly symbol: "\r";
+    static readonly byte: VSBuffer;
+    get byte(): VSBuffer;
+    get text(): "\r";
+    toString(): string;
+}

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/linesCodec/tokens/carriageReturn.js

@@ -0,0 +1,19 @@
+
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { SimpleToken } from '../../simpleCodec/tokens/simpleToken.js';
+
+class CarriageReturn extends SimpleToken {
+    static { this.symbol = '\r'; }
+    static { this.byte = VSBuffer.fromString(CarriageReturn.symbol); }
+    get byte() {
+        return CarriageReturn.byte;
+    }
+    get text() {
+        return CarriageReturn.symbol;
+    }
+    toString() {
+        return `CR${this.range}`;
+    }
+}
+
+export { CarriageReturn };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/linesCodec/tokens/line.d.ts

@@ -0,0 +1,6 @@
+import { BaseToken } from "../../baseToken.js";
+export declare class Line extends BaseToken {
+    readonly text: string;
+    constructor(lineNumber: number, text: string);
+    toString(): string;
+}

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/linesCodec/tokens/line.js

@@ -0,0 +1,20 @@
+
+import { BaseToken } from '../../baseToken.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';
+
+class Line extends BaseToken {
+    constructor(
+    lineNumber,
+    text) {
+        assert(!isNaN(lineNumber), `The line number must not be a NaN.`);
+        assert(lineNumber > 0, `The line number must be >= 1, got "${lineNumber}".`);
+        super(( new Range(lineNumber, 1, lineNumber, text.length + 1)));
+        this.text = text;
+    }
+    toString() {
+        return `line("${this.shortText()}")${this.range}`;
+    }
+}
+
+export { Line };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/linesCodec/tokens/newLine.d.ts

@@ -0,0 +1,9 @@
+import { VSBuffer } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buffer";
+import { SimpleToken } from "../../simpleCodec/tokens/simpleToken.js";
+export declare class NewLine extends SimpleToken<"\n"> {
+    static readonly symbol: "\n";
+    static readonly byte: VSBuffer;
+    get text(): "\n";
+    get byte(): VSBuffer;
+    toString(): string;
+}

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/linesCodec/tokens/newLine.js

@@ -0,0 +1,19 @@
+
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { SimpleToken } from '../../simpleCodec/tokens/simpleToken.js';
+
+class NewLine extends SimpleToken {
+    static { this.symbol = '\n'; }
+    static { this.byte = VSBuffer.fromString(NewLine.symbol); }
+    get text() {
+        return NewLine.symbol;
+    }
+    get byte() {
+        return NewLine.byte;
+    }
+    toString() {
+        return `newline${this.range}`;
+    }
+}
+
+export { NewLine };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/markdownCodec/markdownDecoder.d.ts

@@ -0,0 +1,12 @@
+import { MarkdownToken } from "./tokens/markdownToken.js";
+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 { TSimpleDecoderToken } from "../simpleCodec/simpleDecoder.js";
+import { BaseDecoder } from "../baseDecoder.js";
+export type TMarkdownToken = MarkdownToken | TSimpleDecoderToken;
+export declare class MarkdownDecoder extends BaseDecoder<TMarkdownToken, TSimpleDecoderToken> {
+    private current?;
+    constructor(stream: ReadableStream<VSBuffer>);
+    protected onStreamData(token: TSimpleDecoderToken): void;
+    protected onStreamEnd(): void;
+}

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/markdownCodec/markdownDecoder.js

@@ -0,0 +1,72 @@
+
+import { MarkdownToken } from './tokens/markdownToken.js';
+import { LeftBracket } from '../simpleCodec/tokens/brackets.js';
+import { PartialMarkdownImage } from './parsers/markdownImage.js';
+import { LeftAngleBracket } from '../simpleCodec/tokens/angleBrackets.js';
+import { ExclamationMark } from '../simpleCodec/tokens/exclamationMark.js';
+import { BaseDecoder } from '../baseDecoder.js';
+import { PartialMarkdownCommentStart, MarkdownCommentStart } from './parsers/markdownComment.js';
+import { MarkdownExtensionsDecoder } from '../markdownExtensionsCodec/markdownExtensionsDecoder.js';
+import { PartialMarkdownLinkCaption } from './parsers/markdownLink.js';
+
+class MarkdownDecoder extends BaseDecoder {
+    constructor(stream) {
+        super(( new MarkdownExtensionsDecoder(stream)));
+    }
+    onStreamData(token) {
+        if (token instanceof LeftBracket && !this.current) {
+            this.current = ( new PartialMarkdownLinkCaption(token));
+            return;
+        }
+        if (token instanceof LeftAngleBracket && !this.current) {
+            this.current = ( new PartialMarkdownCommentStart(token));
+            return;
+        }
+        if (token instanceof ExclamationMark && !this.current) {
+            this.current = ( new PartialMarkdownImage(token));
+            return;
+        }
+        if (!this.current) {
+            this._onData.fire(token);
+            return;
+        }
+        const parseResult = this.current.accept(token);
+        if (parseResult.result === 'success') {
+            const { nextParser } = parseResult;
+            if (nextParser instanceof MarkdownToken) {
+                this._onData.fire(nextParser);
+                delete this.current;
+            }
+            else {
+                this.current = nextParser;
+            }
+        }
+        else {
+            for (const currentToken of this.current.tokens) {
+                this._onData.fire(currentToken);
+            }
+            delete this.current;
+        }
+        if (!parseResult.wasTokenConsumed) {
+            this.onStreamData(token);
+        }
+    }
+    onStreamEnd() {
+        if (this.current) {
+            if (this.current instanceof MarkdownCommentStart) {
+                this._onData.fire(this.current.asMarkdownComment());
+                delete this.current;
+                this.onStreamEnd();
+                return;
+            }
+            const { tokens } = this.current;
+            for (const token of [...tokens]) {
+                this._onData.fire(token);
+            }
+            delete this.current;
+        }
+        super.onStreamEnd();
+    }
+}
+
+export { MarkdownDecoder };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/markdownCodec/parsers/markdownComment.d.ts

@@ -0,0 +1,22 @@
+import { Dash } from "../../simpleCodec/tokens/dash.js";
+import { MarkdownComment } from "../tokens/markdownComment.js";
+import { TSimpleDecoderToken } from "../../simpleCodec/simpleDecoder.js";
+import { ExclamationMark } from "../../simpleCodec/tokens/exclamationMark.js";
+import { LeftAngleBracket } from "../../simpleCodec/tokens/angleBrackets.js";
+import { ParserBase, TAcceptTokenResult } from "../../simpleCodec/parserBase.js";
+export declare class PartialMarkdownCommentStart extends ParserBase<TSimpleDecoderToken, PartialMarkdownCommentStart | MarkdownCommentStart> {
+    constructor(token: LeftAngleBracket);
+    accept(token: TSimpleDecoderToken): TAcceptTokenResult<PartialMarkdownCommentStart | MarkdownCommentStart>;
+}
+export declare class MarkdownCommentStart extends ParserBase<TSimpleDecoderToken, MarkdownCommentStart | MarkdownComment> {
+    constructor(tokens: [
+        LeftAngleBracket,
+        ExclamationMark,
+        Dash,
+        Dash
+    ]);
+    accept(token: TSimpleDecoderToken): TAcceptTokenResult<MarkdownCommentStart | MarkdownComment>;
+    asMarkdownComment(): MarkdownComment;
+    private get range();
+    private get endsWithDashes();
+}

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/markdownCodec/parsers/markdownComment.js

@@ -0,0 +1,113 @@
+
+import { __decorate } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { BaseToken } from '../../baseToken.js';
+import { Dash } from '../../simpleCodec/tokens/dash.js';
+import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { MarkdownComment } from '../tokens/markdownComment.js';
+import { ExclamationMark } from '../../simpleCodec/tokens/exclamationMark.js';
+import { LeftAngleBracket, RightAngleBracket } from '../../simpleCodec/tokens/angleBrackets.js';
+import { ParserBase, assertNotConsumed } from '../../simpleCodec/parserBase.js';
+
+class PartialMarkdownCommentStart extends ParserBase {
+    constructor(token) {
+        super([token]);
+    }
+    accept(token) {
+        const lastToken = this.currentTokens[this.currentTokens.length - 1];
+        if (token instanceof ExclamationMark && lastToken instanceof LeftAngleBracket) {
+            this.currentTokens.push(token);
+            return {
+                result: 'success',
+                nextParser: this,
+                wasTokenConsumed: true,
+            };
+        }
+        if (token instanceof Dash) {
+            this.currentTokens.push(token);
+            if (lastToken instanceof ExclamationMark) {
+                return {
+                    result: 'success',
+                    nextParser: this,
+                    wasTokenConsumed: true,
+                };
+            }
+            if (lastToken instanceof Dash) {
+                const token1 = this.currentTokens[0];
+                const token2 = this.currentTokens[1];
+                const token3 = this.currentTokens[2];
+                const token4 = this.currentTokens[3];
+                assert(token1 instanceof LeftAngleBracket, `The first token must be a '<', got '${token1}'.`);
+                assert(token2 instanceof ExclamationMark, `The second token must be a '!', got '${token2}'.`);
+                assert(token3 instanceof Dash, `The third token must be a '-', got '${token3}'.`);
+                assert(token4 instanceof Dash, `The fourth token must be a '-', got '${token4}'.`);
+                this.isConsumed = true;
+                return {
+                    result: 'success',
+                    nextParser: ( new MarkdownCommentStart([token1, token2, token3, token4])),
+                    wasTokenConsumed: true,
+                };
+            }
+        }
+        this.isConsumed = true;
+        return {
+            result: 'failure',
+            wasTokenConsumed: false,
+        };
+    }
+}
+PartialMarkdownCommentStart.__decorator = ( __decorate([
+    assertNotConsumed
+], PartialMarkdownCommentStart.prototype, "accept", null));
+class MarkdownCommentStart extends ParserBase {
+    constructor(tokens) {
+        super(tokens);
+    }
+    accept(token) {
+        if (token instanceof RightAngleBracket && this.endsWithDashes) {
+            this.currentTokens.push(token);
+            return {
+                result: 'success',
+                nextParser: this.asMarkdownComment(),
+                wasTokenConsumed: true,
+            };
+        }
+        this.currentTokens.push(token);
+        return {
+            result: 'success',
+            nextParser: this,
+            wasTokenConsumed: true,
+        };
+    }
+    asMarkdownComment() {
+        this.isConsumed = true;
+        return ( new MarkdownComment(this.range, BaseToken.render(this.currentTokens)));
+    }
+    get range() {
+        const firstToken = this.currentTokens[0];
+        const lastToken = this.currentTokens[this.currentTokens.length - 1];
+        const range = ( new Range(
+            firstToken.range.startLineNumber,
+            firstToken.range.startColumn,
+            lastToken.range.endLineNumber,
+            lastToken.range.endColumn
+        ));
+        return range;
+    }
+    get endsWithDashes() {
+        const lastToken = this.currentTokens[this.currentTokens.length - 1];
+        if (!(lastToken instanceof Dash)) {
+            return false;
+        }
+        const secondLastToken = this.currentTokens[this.currentTokens.length - 2];
+        if (!(secondLastToken instanceof Dash)) {
+            return false;
+        }
+        return true;
+    }
+}
+MarkdownCommentStart.__decorator = ( __decorate([
+    assertNotConsumed
+], MarkdownCommentStart.prototype, "accept", null));
+
+export { MarkdownCommentStart, PartialMarkdownCommentStart };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/markdownCodec/parsers/markdownImage.d.ts

@@ -0,0 +1,10 @@
+import { MarkdownImage } from "../tokens/markdownImage.js";
+import { TSimpleDecoderToken } from "../../simpleCodec/simpleDecoder.js";
+import { ExclamationMark } from "../../simpleCodec/tokens/exclamationMark.js";
+import { ParserBase, TAcceptTokenResult } from "../../simpleCodec/parserBase.js";
+export declare class PartialMarkdownImage extends ParserBase<TSimpleDecoderToken, PartialMarkdownImage | MarkdownImage> {
+    private markdownLinkParser;
+    constructor(token: ExclamationMark);
+    get tokens(): readonly TSimpleDecoderToken[];
+    accept(token: TSimpleDecoderToken): TAcceptTokenResult<PartialMarkdownImage | MarkdownImage>;
+}

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/markdownCodec/parsers/markdownImage.js

@@ -0,0 +1,68 @@
+
+import { __decorate } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { MarkdownLink } from '../tokens/markdownLink.js';
+import { MarkdownImage } from '../tokens/markdownImage.js';
+import { LeftBracket } from '../../simpleCodec/tokens/brackets.js';
+import { ParserBase, assertNotConsumed } from '../../simpleCodec/parserBase.js';
+import { PartialMarkdownLinkCaption } from './markdownLink.js';
+
+class PartialMarkdownImage extends ParserBase {
+    constructor(token) {
+        super([token]);
+    }
+    get tokens() {
+        const linkTokens = this.markdownLinkParser?.tokens ?? [];
+        return [
+            ...this.currentTokens,
+            ...linkTokens,
+        ];
+    }
+    accept(token) {
+        if (!this.markdownLinkParser) {
+            if (token instanceof LeftBracket) {
+                this.markdownLinkParser = ( new PartialMarkdownLinkCaption(token));
+                return {
+                    result: 'success',
+                    nextParser: this,
+                    wasTokenConsumed: true,
+                };
+            }
+            return {
+                result: 'failure',
+                wasTokenConsumed: false,
+            };
+        }
+        const acceptResult = this.markdownLinkParser.accept(token);
+        const { result, wasTokenConsumed } = acceptResult;
+        if (result === 'success') {
+            const { nextParser } = acceptResult;
+            if (nextParser instanceof MarkdownLink) {
+                this.isConsumed = true;
+                const firstToken = this.currentTokens[0];
+                return {
+                    result,
+                    wasTokenConsumed,
+                    nextParser: ( new MarkdownImage(
+                        firstToken.range.startLineNumber,
+                        firstToken.range.startColumn,
+                        `${firstToken.text}${nextParser.caption}`,
+                        nextParser.reference
+                    )),
+                };
+            }
+            this.markdownLinkParser = nextParser;
+            return {
+                result,
+                wasTokenConsumed,
+                nextParser: this,
+            };
+        }
+        this.isConsumed = true;
+        return acceptResult;
+    }
+}
+PartialMarkdownImage.__decorator = ( __decorate([
+    assertNotConsumed
+], PartialMarkdownImage.prototype, "accept", null));
+
+export { PartialMarkdownImage };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/markdownCodec/parsers/markdownLink.d.ts

@@ -0,0 +1,19 @@
+import { MarkdownLink } from "../tokens/markdownLink.js";
+import { TSimpleDecoderToken } from "../../simpleCodec/simpleDecoder.js";
+import { LeftBracket } from "../../simpleCodec/tokens/brackets.js";
+import { ParserBase, TAcceptTokenResult } from "../../simpleCodec/parserBase.js";
+import { LeftParenthesis } from "../../simpleCodec/tokens/parentheses.js";
+export declare class PartialMarkdownLinkCaption extends ParserBase<TSimpleDecoderToken, PartialMarkdownLinkCaption | MarkdownLinkCaption> {
+    constructor(token: LeftBracket);
+    accept(token: TSimpleDecoderToken): TAcceptTokenResult<PartialMarkdownLinkCaption | MarkdownLinkCaption>;
+}
+export declare class MarkdownLinkCaption extends ParserBase<TSimpleDecoderToken, MarkdownLinkCaption | PartialMarkdownLink> {
+    accept(token: TSimpleDecoderToken): TAcceptTokenResult<MarkdownLinkCaption | PartialMarkdownLink>;
+}
+export declare class PartialMarkdownLink extends ParserBase<TSimpleDecoderToken, PartialMarkdownLink | MarkdownLink> {
+    protected readonly captionTokens: TSimpleDecoderToken[];
+    private openParensCount;
+    constructor(captionTokens: TSimpleDecoderToken[], token: LeftParenthesis);
+    get tokens(): readonly TSimpleDecoderToken[];
+    accept(token: TSimpleDecoderToken): TAcceptTokenResult<PartialMarkdownLink | MarkdownLink>;
+}

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/markdownCodec/parsers/markdownLink.js

@@ -0,0 +1,99 @@
+
+import { BaseToken } from '../../baseToken.js';
+import { MarkdownLink } from '../tokens/markdownLink.js';
+import { NewLine } from '../../linesCodec/tokens/newLine.js';
+import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { FormFeed } from '../../simpleCodec/tokens/formFeed.js';
+import { VerticalTab } from '../../simpleCodec/tokens/verticalTab.js';
+import { CarriageReturn } from '../../linesCodec/tokens/carriageReturn.js';
+import { RightBracket } from '../../simpleCodec/tokens/brackets.js';
+import { ParserBase } from '../../simpleCodec/parserBase.js';
+import { LeftParenthesis, RightParenthesis } from '../../simpleCodec/tokens/parentheses.js';
+
+const MARKDOWN_LINK_STOP_CHARACTERS = ( [CarriageReturn, NewLine, VerticalTab, FormFeed]
+    .map((token) => { return token.symbol; }));
+class PartialMarkdownLinkCaption extends ParserBase {
+    constructor(token) {
+        super([token]);
+    }
+    accept(token) {
+        if (MARKDOWN_LINK_STOP_CHARACTERS.includes(token.text)) {
+            return {
+                result: 'failure',
+                wasTokenConsumed: false,
+            };
+        }
+        if (token instanceof RightBracket) {
+            return {
+                result: 'success',
+                nextParser: ( new MarkdownLinkCaption([...this.tokens, token])),
+                wasTokenConsumed: true,
+            };
+        }
+        this.currentTokens.push(token);
+        return {
+            result: 'success',
+            nextParser: this,
+            wasTokenConsumed: true,
+        };
+    }
+}
+class MarkdownLinkCaption extends ParserBase {
+    accept(token) {
+        if (token instanceof LeftParenthesis) {
+            return {
+                result: 'success',
+                wasTokenConsumed: true,
+                nextParser: ( new PartialMarkdownLink([...this.tokens], token)),
+            };
+        }
+        return {
+            result: 'failure',
+            wasTokenConsumed: false,
+        };
+    }
+}
+class PartialMarkdownLink extends ParserBase {
+    constructor(captionTokens, token) {
+        super([token]);
+        this.captionTokens = captionTokens;
+        this.openParensCount = 1;
+    }
+    get tokens() {
+        return [...this.captionTokens, ...this.currentTokens];
+    }
+    accept(token) {
+        if (token instanceof LeftParenthesis) {
+            this.openParensCount += 1;
+        }
+        if (token instanceof RightParenthesis) {
+            this.openParensCount -= 1;
+            assert(this.openParensCount >= 0, `Unexpected right parenthesis token encountered: '${token}'.`);
+            if (this.openParensCount === 0) {
+                const { startLineNumber, startColumn } = this.captionTokens[0].range;
+                const caption = BaseToken.render(this.captionTokens);
+                this.currentTokens.push(token);
+                const reference = BaseToken.render(this.currentTokens);
+                return {
+                    result: 'success',
+                    wasTokenConsumed: true,
+                    nextParser: ( new MarkdownLink(startLineNumber, startColumn, caption, reference)),
+                };
+            }
+        }
+        if (MARKDOWN_LINK_STOP_CHARACTERS.includes(token.text)) {
+            return {
+                result: 'failure',
+                wasTokenConsumed: false,
+            };
+        }
+        this.currentTokens.push(token);
+        return {
+            result: 'success',
+            nextParser: this,
+            wasTokenConsumed: true,
+        };
+    }
+}
+
+export { MarkdownLinkCaption, PartialMarkdownLink, PartialMarkdownLinkCaption };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/markdownCodec/tokens/markdownComment.d.ts

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

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/markdownCodec/tokens/markdownComment.js

@@ -0,0 +1,19 @@
+
+import { MarkdownToken } from './markdownToken.js';
+import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+
+class MarkdownComment extends MarkdownToken {
+    constructor(range, text) {
+        assert(text.startsWith('<!--'), `The comment must start with '<!--', got '${text.substring(0, 10)}'.`);
+        super(range);
+        this.text = text;
+    }
+    get hasEndMarker() {
+        return this.text.endsWith('-->');
+    }
+    toString() {
+        return `md-comment("${this.shortText()}")${this.range}`;
+    }
+}
+
+export { MarkdownComment };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/markdownCodec/tokens/markdownImage.d.ts

@@ -0,0 +1,12 @@
+import { MarkdownToken } from "./markdownToken.js";
+import { IRange } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+export declare class MarkdownImage extends MarkdownToken {
+    private readonly caption;
+    private readonly reference;
+    readonly isURL: boolean;
+    constructor(lineNumber: number, columnNumber: number, caption: string, reference: string);
+    get text(): string;
+    get path(): string;
+    get linkRange(): IRange | undefined;
+    toString(): string;
+}