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

package/vscode/src/vs/workbench/contrib/chat/common/chatSessionStore.d.ts

@@ -8,8 +8,8 @@ import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platfo
 import { IUserDataProfilesService } from "@codingame/monaco-vscode-api/vscode/vs/platform/userDataProfile/common/userDataProfile.service";
 import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
 import { ILifecycleService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
-import { ChatModel, ISerializableChatData, ISerializableChatsData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModel";
-import { ChatAgentLocation, ChatMode } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
+import { ChatModel, ISerializableChatData, ISerializableChatsData } from "@codingame/monaco-vscode-9911aec2-e4dd-5483-8369-9d695cc70d8a-common/vscode/vs/workbench/contrib/chat/common/chatModel";
+import { ChatAgentLocation, ChatModeKind } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
 export declare class ChatSessionStore extends Disposable {
     private readonly fileService;
     private readonly environmentService;
@@ -62,7 +62,7 @@ export interface IChatTransfer {
     timestampInMilliseconds: number;
     inputValue: string;
     location: ChatAgentLocation;
-    mode: ChatMode;
+    mode: ChatModeKind;
 }
 export interface IChatTransfer2 extends IChatTransfer {
     chat: ISerializableChatData;

package/vscode/src/vs/workbench/contrib/chat/common/chatSessionStore.js

@@ -18,7 +18,7 @@ import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platfo
 import { IUserDataProfilesService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
 import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
 import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
-import { normalizeSerializableChatData, ChatModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModel';
+import { normalizeSerializableChatData, ChatModel } from '@codingame/monaco-vscode-9911aec2-e4dd-5483-8369-9d695cc70d8a-common/vscode/vs/workbench/contrib/chat/common/chatModel';
 
 const maxPersistedSessions = 25;
 const ChatIndexStorageKey = 'chat.ChatSessionStore.index';
@@ -51,7 +51,7 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
             }
             e.join(this.storeTask, {
                 id: 'join.chatSessionStore',
-                label: ( localize(5164, "Saving chat history"))
+                label: ( localize(5300, "Saving chat history"))
             });
         }));
     }
@@ -324,7 +324,7 @@ function isChatSessionIndex(data) {
 }
 function getSessionMetadata(session) {
     const title = session instanceof ChatModel ?
-        (session.title || ( localize(5165, "New Chat"))) :
+        (session.title || ( localize(5301, "New Chat"))) :
         session.customTitle ?? ChatModel.getDefaultTitle(session.requests);
     return {
         sessionId: session.sessionId,

package/vscode/src/vs/workbench/contrib/chat/common/chatSlashCommands.d.ts

@@ -5,7 +5,7 @@ import { IProgress } from "@codingame/monaco-vscode-api/vscode/vs/platform/progr
 import { IChatMessage } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels";
 import { IChatFollowup, IChatProgress, IChatResponseProgressFileTreeData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
 import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
-import { ChatAgentLocation, ChatMode } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
+import { ChatAgentLocation, ChatModeKind } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
 import { IChatSlashCommandService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSlashCommands.service";
 export interface IChatSlashData {
     command: string;
@@ -14,7 +14,7 @@ export interface IChatSlashData {
     executeImmediately?: boolean;
     silent?: boolean;
     locations: ChatAgentLocation[];
-    modes?: ChatMode[];
+    modes?: ChatModeKind[];
 }
 export interface IChatSlashFragment {
     content: string | {
@@ -35,7 +35,7 @@ export declare class ChatSlashCommandService extends Disposable implements IChat
     constructor(_extensionService: IExtensionService);
     dispose(): void;
     registerSlashCommand(data: IChatSlashData, command: IChatSlashCallback): IDisposable;
-    getCommands(location: ChatAgentLocation, mode: ChatMode): Array<IChatSlashData>;
+    getCommands(location: ChatAgentLocation, mode: ChatModeKind): Array<IChatSlashData>;
     hasCommand(id: string): boolean;
     executeCommand(id: string, prompt: string, progress: IProgress<IChatProgress>, history: IChatMessage[], location: ChatAgentLocation, token: CancellationToken): Promise<{
         followUp: IChatFollowup[];

package/vscode/src/vs/workbench/contrib/chat/common/promptFileReferenceErrors.d.ts

@@ -0,0 +1,40 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+declare abstract class ParseError extends Error {
+    abstract readonly errorType: string;
+    constructor(message?: string, options?: ErrorOptions);
+    sameTypeAs(other: unknown): other is typeof this;
+    equal(other: unknown): boolean;
+}
+export declare abstract class ResolveError extends ParseError {
+    readonly uri: URI;
+    abstract errorType: string;
+    constructor(uri: URI, message?: string, options?: ErrorOptions);
+}
+export declare class FailedToResolveContentsStream extends ResolveError {
+    readonly originalError: unknown;
+    errorType: string;
+    constructor(uri: URI, originalError: unknown, message?: string);
+}
+export declare class OpenFailed extends FailedToResolveContentsStream {
+    errorType: string;
+    constructor(uri: URI, originalError: unknown);
+}
+export declare class RecursiveReference extends ResolveError {
+    readonly recursivePath: readonly string[];
+    errorType: string;
+    private defaultPathStringCache;
+    constructor(uri: URI, recursivePath: readonly string[]);
+    get message(): string;
+    getRecursivePathString(filename: "basename" | "fullpath", pathJoinCharacter?: string): string;
+    equal(other: unknown): other is this;
+    toString(): string;
+}
+export declare class NotPromptFile extends ResolveError {
+    errorType: string;
+    constructor(uri: URI, message?: string);
+}
+export declare class FolderReference extends NotPromptFile {
+    errorType: string;
+    constructor(uri: URI, message?: string);
+}
+export {};

package/vscode/src/vs/workbench/contrib/chat/common/promptFileReferenceErrors.js

@@ -0,0 +1,107 @@
+
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import { assert, assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+
+class ParseError extends Error {
+    constructor(message, options) {
+        super(message, options);
+    }
+    sameTypeAs(other) {
+        if (other === null || other === undefined) {
+            return false;
+        }
+        return other instanceof this.constructor;
+    }
+    equal(other) {
+        return this.sameTypeAs(other);
+    }
+}
+class ResolveError extends ParseError {
+    constructor(uri, message, options) {
+        super(message, options);
+        this.uri = uri;
+    }
+}
+class FailedToResolveContentsStream extends ResolveError {
+    constructor(uri, originalError, message = `Failed to resolve prompt contents stream for '${( uri.toString())}': ${originalError}.`) {
+        super(uri, message);
+        this.originalError = originalError;
+        this.errorType = 'FailedToResolveContentsStream';
+    }
+}
+class OpenFailed extends FailedToResolveContentsStream {
+    constructor(uri, originalError) {
+        super(uri, originalError, `Failed to open '${uri.fsPath}': ${originalError}.`);
+        this.errorType = 'OpenError';
+    }
+}
+const DEFAULT_RECURSIVE_PATH_JOIN_CHAR = ' -> ';
+class RecursiveReference extends ResolveError {
+    constructor(uri, recursivePath) {
+        assert(recursivePath.length >= 2, `Recursive path must contain at least two paths, got '${recursivePath.length}'.`);
+        super(uri, 'Recursive references found.');
+        this.recursivePath = recursivePath;
+        this.errorType = 'RecursiveReferenceError';
+    }
+    get message() {
+        return `${super.message} ${this.getRecursivePathString('fullpath')}`;
+    }
+    getRecursivePathString(filename, pathJoinCharacter = DEFAULT_RECURSIVE_PATH_JOIN_CHAR) {
+        const isDefault = (filename === 'fullpath') &&
+            (pathJoinCharacter === DEFAULT_RECURSIVE_PATH_JOIN_CHAR);
+        if (isDefault && (this.defaultPathStringCache !== undefined)) {
+            return this.defaultPathStringCache;
+        }
+        const result = ( this.recursivePath
+            .map((path) => {
+            if (filename === 'fullpath') {
+                return `'${path}'`;
+            }
+            if (filename === 'basename') {
+                return `'${basename(path)}'`;
+            }
+            assertNever(filename, `Unknown filename format '${filename}'.`);
+        }))
+            .join(pathJoinCharacter);
+        if (isDefault) {
+            this.defaultPathStringCache = result;
+        }
+        return result;
+    }
+    equal(other) {
+        if (!this.sameTypeAs(other)) {
+            return false;
+        }
+        if (( this.uri.toString()) !== ( other.uri.toString())) {
+            return false;
+        }
+        if (this.recursivePath.length !== other.recursivePath.length) {
+            return false;
+        }
+        const myRecursivePath = this.getRecursivePathString('fullpath');
+        const theirRecursivePath = other.getRecursivePathString('fullpath');
+        if (myRecursivePath.length !== theirRecursivePath.length) {
+            return false;
+        }
+        return myRecursivePath === theirRecursivePath;
+    }
+    toString() {
+        return `"${this.message}"(${this.uri})`;
+    }
+}
+class NotPromptFile extends ResolveError {
+    constructor(uri, message = '') {
+        const suffix = message ? `: ${message}` : '';
+        super(uri, `Resource at ${uri.path} is not a prompt file${suffix}`);
+        this.errorType = 'NotPromptFileError';
+    }
+}
+class FolderReference extends NotPromptFile {
+    constructor(uri, message = '') {
+        const suffix = message ? `: ${message}` : '';
+        super(uri, `Entity at '${uri.path}' is a folder${suffix}`);
+        this.errorType = 'FolderReferenceError';
+    }
+}
+
+export { FailedToResolveContentsStream, FolderReference, NotPromptFile, OpenFailed, RecursiveReference, ResolveError };

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

@@ -0,0 +1,9 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { BaseDecoder } from "./baseDecoder.js";
+export declare class AsyncDecoder<T extends NonNullable<unknown>, K extends NonNullable<unknown> = NonNullable<unknown>> extends Disposable {
+    private readonly decoder;
+    private readonly messages;
+    private resolveOnNewEvent?;
+    constructor(decoder: BaseDecoder<T, K>);
+    [Symbol.asyncIterator](): AsyncIterator<T | null>;
+}

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

@@ -0,0 +1,45 @@
+
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+
+class AsyncDecoder extends Disposable {
+    constructor(decoder) {
+        super();
+        this.decoder = decoder;
+        this.messages = [];
+        this._register(decoder);
+    }
+    async *[Symbol.asyncIterator]() {
+        const callback = (data) => {
+            if (data !== undefined) {
+                this.messages.push(data);
+            }
+            else {
+                this.decoder.removeListener('data', callback);
+                this.decoder.removeListener('end', callback);
+            }
+            if (this.resolveOnNewEvent) {
+                this.resolveOnNewEvent();
+                delete this.resolveOnNewEvent;
+            }
+        };
+        this.decoder.on('end', callback);
+        this.decoder.on('data', callback);
+        this.decoder.start();
+        while (true) {
+            const maybeMessage = this.messages.shift();
+            if (maybeMessage !== undefined) {
+                yield maybeMessage;
+                continue;
+            }
+            if (this.decoder.ended) {
+                this.dispose();
+                return null;
+            }
+            await ( new Promise((resolve) => {
+                this.resolveOnNewEvent = resolve;
+            }));
+        }
+    }
+}
+
+export { AsyncDecoder };

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

@@ -0,0 +1,35 @@
+import { Emitter } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { ReadableStream } from "@codingame/monaco-vscode-api/vscode/vs/base/common/stream";
+import { ObservableDisposable } from "../../utils/observableDisposable.js";
+export type TStreamListenerNames = "data" | "error" | "end";
+export declare abstract class BaseDecoder<T extends NonNullable<unknown>, K extends NonNullable<unknown> = NonNullable<unknown>> extends ObservableDisposable implements ReadableStream<T> {
+    protected readonly stream: ReadableStream<K>;
+    private _ended;
+    protected readonly _onData: Emitter<T>;
+    private readonly _onEnd;
+    private readonly _onError;
+    private readonly _listeners;
+    protected abstract onStreamData(data: K): void;
+    constructor(stream: ReadableStream<K>);
+    private started;
+    private settledPromise;
+    get settled(): Promise<boolean>;
+    start(): this;
+    get ended(): boolean;
+    private tryOnStreamData;
+    on(event: "data", callback: (data: T) => void): void;
+    on(event: "error", callback: (err: Error) => void): void;
+    on(event: "end", callback: () => void): void;
+    onData(callback: (data: T) => void): void;
+    onError(callback: (error: Error) => void): void;
+    onEnd(callback: () => void): void;
+    pause(): void;
+    resume(): void;
+    destroy(): void;
+    removeListener(eventName: TStreamListenerNames, callback: Function): void;
+    protected onStreamEnd(): void;
+    private onStreamError;
+    consumeAll(): Promise<T[]>;
+    [Symbol.asyncIterator](): AsyncIterator<T | null>;
+    dispose(): void;
+}

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

@@ -0,0 +1,150 @@
+
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { AsyncDecoder } from './asyncDecoder.js';
+import { assert, assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ObservableDisposable } from '../../utils/observableDisposable.js';
+
+class BaseDecoder extends ObservableDisposable {
+    constructor(stream) {
+        super();
+        this.stream = stream;
+        this._ended = false;
+        this._onData = this._register(( new Emitter()));
+        this._onEnd = this._register(( new Emitter()));
+        this._onError = this._register(( new Emitter()));
+        this._listeners = this._register(( new DisposableMap()));
+        this.started = false;
+        this.settledPromise = ( new DeferredPromise());
+    }
+    get settled() {
+        assert(this.started, [
+            'Cannot get `settled` promise of a stream that has not been started.',
+            'Please call `start()` first.',
+        ].join(' '));
+        return this.settledPromise.p;
+    }
+    start() {
+        assert(this._ended === false, 'Cannot start stream that has already ended.');
+        assert(this.isDisposed === false, 'Cannot start stream that has already disposed.');
+        if (this.started) {
+            return this;
+        }
+        this.started = true;
+        this.stream.on('end', this.onStreamEnd.bind(this));
+        this.stream.on('error', this.onStreamError.bind(this));
+        this.stream.on('data', this.tryOnStreamData.bind(this));
+        if (this.stream instanceof BaseDecoder) {
+            this.stream.start();
+        }
+        return this;
+    }
+    get ended() {
+        return this._ended;
+    }
+    tryOnStreamData(data) {
+        try {
+            this.onStreamData(data);
+        }
+        catch (error) {
+            this.onStreamError(error);
+        }
+    }
+    on(event, callback) {
+        if (event === 'data') {
+            return this.onData(callback);
+        }
+        if (event === 'error') {
+            return this.onError(callback);
+        }
+        if (event === 'end') {
+            return this.onEnd(callback);
+        }
+        assertNever(event, `Invalid event name '${event}'`);
+    }
+    onData(callback) {
+        assert(!this.ended, 'Cannot subscribe to the `data` event because the decoder stream has already ended.');
+        let currentListeners = this._listeners.get('data');
+        if (!currentListeners) {
+            currentListeners = ( new DisposableMap());
+            this._listeners.set('data', currentListeners);
+        }
+        currentListeners.set(callback, this._onData.event(callback));
+    }
+    onError(callback) {
+        assert(!this.ended, 'Cannot subscribe to the `error` event because the decoder stream has already ended.');
+        let currentListeners = this._listeners.get('error');
+        if (!currentListeners) {
+            currentListeners = ( new DisposableMap());
+            this._listeners.set('error', currentListeners);
+        }
+        currentListeners.set(callback, this._onError.event(callback));
+    }
+    onEnd(callback) {
+        assert(!this.ended, 'Cannot subscribe to the `end` event because the decoder stream has already ended.');
+        let currentListeners = this._listeners.get('end');
+        if (!currentListeners) {
+            currentListeners = ( new DisposableMap());
+            this._listeners.set('end', currentListeners);
+        }
+        currentListeners.set(callback, this._onEnd.event(callback));
+    }
+    pause() {
+        this.stream.pause();
+    }
+    resume() {
+        assert(this.ended === false, 'Cannot resume the stream because it has already ended.');
+        this.stream.resume();
+    }
+    destroy() {
+        this.dispose();
+    }
+    removeListener(eventName, callback) {
+        const listeners = this._listeners.get(eventName);
+        if (listeners === undefined) {
+            return;
+        }
+        for (const [listener] of listeners) {
+            if (listener !== callback) {
+                continue;
+            }
+            listeners.deleteAndDispose(listener);
+        }
+    }
+    onStreamEnd() {
+        if (this._ended) {
+            return;
+        }
+        this._ended = true;
+        this._onEnd.fire();
+        this.settledPromise.complete(this._ended);
+    }
+    onStreamError(error) {
+        this._onError.fire(error);
+    }
+    async consumeAll() {
+        assert(!this._ended, 'Cannot consume all messages of the stream that has already ended.');
+        const messages = [];
+        for await (const maybeMessage of this) {
+            if (maybeMessage === null) {
+                break;
+            }
+            messages.push(maybeMessage);
+        }
+        return messages;
+    }
+    [Symbol.asyncIterator]() {
+        assert(!this._ended, 'Cannot iterate on messages of the stream that has already ended.');
+        const asyncDecoder = this._register(( new AsyncDecoder(this)));
+        return asyncDecoder[Symbol.asyncIterator]();
+    }
+    dispose() {
+        this.settledPromise.complete(this.ended);
+        this._listeners.clearAndDisposeAll();
+        this.stream.destroy();
+        super.dispose();
+    }
+}
+
+export { BaseDecoder };

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

@@ -0,0 +1,15 @@
+import { IRange, Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+export declare abstract class BaseToken<TText extends string = string> {
+    private tokenRange;
+    constructor(tokenRange: Range);
+    get range(): Range;
+    abstract get text(): TText;
+    sameRange(other: Range): boolean;
+    abstract toString(): string;
+    equals(other: BaseToken): other is typeof this;
+    withRange(components: Partial<IRange>): this;
+    collapseRangeToStart(): this;
+    static render(tokens: readonly BaseToken[], delimiter?: string): string;
+    static fullRange(tokens: readonly BaseToken[]): Range;
+    shortText(maxLength?: number): string;
+}

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

@@ -0,0 +1,69 @@
+
+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 BaseToken {
+    constructor(tokenRange) {
+        this.tokenRange = tokenRange;
+    }
+    get range() {
+        return this.tokenRange;
+    }
+    sameRange(other) {
+        return this.range.equalsRange(other);
+    }
+    equals(other) {
+        if (other.constructor !== this.constructor) {
+            return false;
+        }
+        if (this.text.length !== other.text.length) {
+            return false;
+        }
+        if (this.text !== other.text) {
+            return false;
+        }
+        return this.sameRange(other.range);
+    }
+    withRange(components) {
+        this.tokenRange = ( new Range(
+            components.startLineNumber ?? this.range.startLineNumber,
+            components.startColumn ?? this.range.startColumn,
+            components.endLineNumber ?? this.range.endLineNumber,
+            components.endColumn ?? this.range.endColumn
+        ));
+        return this;
+    }
+    collapseRangeToStart() {
+        this.tokenRange = this.tokenRange.collapseToStart();
+        return this;
+    }
+    static render(tokens, delimiter = '') {
+        return ( tokens.map(token => token.text)).join(delimiter);
+    }
+    static fullRange(tokens) {
+        assert(tokens.length > 0, 'Cannot get full range for an empty list of tokens.');
+        const firstToken = tokens[0];
+        const lastToken = tokens[tokens.length - 1];
+        assert(firstToken.range.startLineNumber <= lastToken.range.startLineNumber, 'First token must start on previous or the same line as the last token.');
+        if ((firstToken !== lastToken) && (firstToken.range.startLineNumber === lastToken.range.startLineNumber)) {
+            assert(firstToken.range.endColumn <= lastToken.range.startColumn, [
+                'First token must end at least on previous or the same column as the last token.',
+                `First token: ${firstToken}; Last token: ${lastToken}.`,
+            ].join('\n'));
+        }
+        return ( new Range(
+            firstToken.range.startLineNumber,
+            firstToken.range.startColumn,
+            lastToken.range.endLineNumber,
+            lastToken.range.endColumn
+        ));
+    }
+    shortText(maxLength = 32) {
+        if (this.text.length <= maxLength) {
+            return this.text;
+        }
+        return `${this.text.slice(0, maxLength - 1)}...`;
+    }
+}
+
+export { BaseToken };

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

@@ -0,0 +1,10 @@
+import { BaseToken } from "./baseToken.js";
+export declare abstract class CompositeToken<TTokens extends readonly BaseToken[]> extends BaseToken {
+    protected readonly childTokens: [
+        ...TTokens
+    ];
+    constructor(tokens: TTokens);
+    get text(): string;
+    get children(): TTokens;
+    equals(other: BaseToken): other is typeof this;
+}

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

@@ -0,0 +1,33 @@
+
+import { BaseToken } from './baseToken.js';
+
+class CompositeToken extends BaseToken {
+    constructor(tokens) {
+        super(BaseToken.fullRange(tokens));
+        this.childTokens = [...tokens];
+    }
+    get text() {
+        return BaseToken.render(this.childTokens);
+    }
+    get children() {
+        return this.childTokens;
+    }
+    equals(other) {
+        if (super.equals(other) === false) {
+            return false;
+        }
+        if (this.children.length !== other.children.length) {
+            return false;
+        }
+        for (let i = 0; i < this.children.length; i++) {
+            const childToken = this.children[i];
+            const otherChildToken = other.children[i];
+            if (childToken.equals(otherChildToken) === false) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+
+export { CompositeToken };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/constants.d.ts

@@ -0,0 +1,4 @@
+import { NewLine } from "../linesCodec/tokens/newLine.js";
+import { CarriageReturn } from "../linesCodec/tokens/carriageReturn.js";
+import { FormFeed, SpacingToken } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/simpleCodec/tokens/tokens";
+export declare const VALID_INTER_RECORD_SPACING_TOKENS: readonly (typeof SpacingToken | typeof FormFeed | typeof NewLine | typeof CarriageReturn)[];

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/constants.js

@@ -0,0 +1,29 @@
+
+import { NewLine } from '../linesCodec/tokens/newLine.js';
+import { CarriageReturn } from '../linesCodec/tokens/carriageReturn.js';
+import '../simpleCodec/tokens/at.js';
+import '../simpleCodec/tokens/tab.js';
+import '../simpleCodec/tokens/dash.js';
+import '../simpleCodec/tokens/hash.js';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import '../simpleCodec/tokens/colon.js';
+import '../simpleCodec/tokens/quote.js';
+import '../simpleCodec/tokens/slash.js';
+import '../simpleCodec/tokens/space.js';
+import '../simpleCodec/tokens/comma.js';
+import { FormFeed } from '../simpleCodec/tokens/formFeed.js';
+import '../simpleCodec/tokens/dollarSign.js';
+import '../simpleCodec/tokens/verticalTab.js';
+import '../simpleCodec/tokens/doubleQuote.js';
+import '../simpleCodec/tokens/exclamationMark.js';
+import { SpacingToken } from '../simpleCodec/tokens/simpleToken.js';
+import '../simpleCodec/tokens/brackets.js';
+import '../simpleCodec/tokens/curlyBraces.js';
+import '../simpleCodec/tokens/parentheses.js';
+import '../simpleCodec/tokens/angleBrackets.js';
+
+const VALID_INTER_RECORD_SPACING_TOKENS = ( Object.freeze([
+    SpacingToken, CarriageReturn, NewLine, FormFeed,
+]));
+
+export { VALID_INTER_RECORD_SPACING_TOKENS };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/frontMatterDecoder.d.ts

@@ -0,0 +1,15 @@
+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 { FrontMatterRecord } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/tokens/index";
+import { BaseDecoder } from "../baseDecoder.js";
+import { type TSimpleDecoderToken } from "../simpleCodec/simpleDecoder.js";
+import { ObjectStream } from "../utils/objectStream.js";
+export type TFrontMatterToken = FrontMatterRecord | TSimpleDecoderToken;
+export declare class FrontMatterDecoder extends BaseDecoder<TFrontMatterToken, TSimpleDecoderToken> {
+    private current?;
+    private readonly parserFactory;
+    constructor(stream: ReadableStream<VSBuffer> | ObjectStream<TSimpleDecoderToken>);
+    protected onStreamData(token: TSimpleDecoderToken): void;
+    protected onStreamEnd(): void;
+    protected reEmitCurrentTokens(): void;
+}