@codingame/monaco-vscode-chat-service-override 15.0.2 → 16.0.0

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

@@ -0,0 +1,313 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Sequencer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
+import { joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';
+import { toFileOperationResult, FileOperationResult } 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';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { StorageTarget, StorageScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.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-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatModel';
+
+const maxPersistedSessions = 25;
+const ChatIndexStorageKey = 'chat.ChatSessionStore.index';
+let ChatSessionStore = class ChatSessionStore extends Disposable {
+    constructor(fileService, environmentService, logService, workspaceContextService, telemetryService, storageService, lifecycleService) {
+        super();
+        this.fileService = fileService;
+        this.environmentService = environmentService;
+        this.logService = logService;
+        this.workspaceContextService = workspaceContextService;
+        this.telemetryService = telemetryService;
+        this.storageService = storageService;
+        this.lifecycleService = lifecycleService;
+        this.storeQueue = ( new Sequencer());
+        this.shuttingDown = false;
+        const workspace = this.workspaceContextService.getWorkspace();
+        const isEmptyWindow = !workspace.configuration && workspace.folders.length === 0;
+        const workspaceId = isEmptyWindow ?
+            'no-workspace' :
+            this.workspaceContextService.getWorkspace().id;
+        this.storageRoot = joinPath(this.environmentService.workspaceStorageHome, workspaceId, 'chatSessions');
+        this._register(this.lifecycleService.onWillShutdown(e => {
+            this.shuttingDown = true;
+            if (!this.storeTask) {
+                return;
+            }
+            e.join(this.storeTask, {
+                id: 'join.chatSessionStore',
+                label: ( localize(4986, "Saving chat history"))
+            });
+        }));
+    }
+    async storeSessions(sessions) {
+        if (this.shuttingDown) {
+            return;
+        }
+        try {
+            this.storeTask = this.storeQueue.queue(async () => {
+                try {
+                    await Promise.all(( sessions.map(session => this.writeSession(session))));
+                    await this.trimEntries();
+                    await this.flushIndex();
+                }
+                catch (e) {
+                    this.reportError('storeSessions', 'Error storing chat sessions', e);
+                }
+            });
+            await this.storeTask;
+        }
+        finally {
+            this.storeTask = undefined;
+        }
+    }
+    async writeSession(session) {
+        try {
+            const index = this.internalGetIndex();
+            const storageLocation = this.getStorageLocation(session.sessionId);
+            const content = JSON.stringify(session, undefined, 2);
+            await this.fileService.writeFile(storageLocation, VSBuffer.fromString(content));
+            index.entries[session.sessionId] = getSessionMetadata(session);
+        }
+        catch (e) {
+            this.reportError('sessionWrite', 'Error writing chat session', e);
+        }
+    }
+    async flushIndex() {
+        const index = this.internalGetIndex();
+        try {
+            this.storageService.store(ChatIndexStorageKey, index, this.getIndexStorageScope(), StorageTarget.MACHINE);
+        }
+        catch (e) {
+            this.reportError('indexWrite', 'Error writing index', e);
+        }
+    }
+    getIndexStorageScope() {
+        const workspace = this.workspaceContextService.getWorkspace();
+        const isEmptyWindow = !workspace.configuration && workspace.folders.length === 0;
+        return isEmptyWindow ? StorageScope.APPLICATION : StorageScope.WORKSPACE;
+    }
+    async trimEntries() {
+        const index = this.internalGetIndex();
+        const entries = ( Object.entries(index.entries)
+            .sort((a, b) => b[1].lastMessageDate - a[1].lastMessageDate)
+            .map(([id]) => id));
+        if (entries.length > maxPersistedSessions) {
+            const entriesToDelete = entries.slice(maxPersistedSessions);
+            for (const entry of entriesToDelete) {
+                delete index.entries[entry];
+            }
+            this.logService.trace(`ChatSessionStore: Trimmed ${entriesToDelete.length} old chat sessions from index`);
+        }
+    }
+    async internalDeleteSession(sessionId) {
+        const index = this.internalGetIndex();
+        if (!index.entries[sessionId]) {
+            return;
+        }
+        const storageLocation = this.getStorageLocation(sessionId);
+        try {
+            await this.fileService.del(storageLocation);
+        }
+        catch (e) {
+            if (toFileOperationResult(e) !== FileOperationResult.FILE_NOT_FOUND) {
+                this.reportError('sessionDelete', 'Error deleting chat session', e);
+            }
+        }
+        finally {
+            delete index.entries[sessionId];
+        }
+    }
+    hasSessions() {
+        return ( Object.keys(this.internalGetIndex().entries)).length > 0;
+    }
+    isSessionEmpty(sessionId) {
+        const index = this.internalGetIndex();
+        return index.entries[sessionId]?.isEmpty ?? true;
+    }
+    async deleteSession(sessionId) {
+        await this.storeQueue.queue(async () => {
+            await this.internalDeleteSession(sessionId);
+            await this.flushIndex();
+        });
+    }
+    async clearAllSessions() {
+        await this.storeQueue.queue(async () => {
+            const index = this.internalGetIndex();
+            const entries = ( Object.keys(index.entries));
+            this.logService.info(`ChatSessionStore: Clearing ${entries.length} chat sessions`);
+            await Promise.all(( entries.map(entry => this.internalDeleteSession(entry))));
+            await this.flushIndex();
+        });
+    }
+    async setSessionTitle(sessionId, title) {
+        await this.storeQueue.queue(async () => {
+            const index = this.internalGetIndex();
+            if (index.entries[sessionId]) {
+                index.entries[sessionId].title = title;
+            }
+        });
+    }
+    reportError(reasonForTelemetry, message, error) {
+        this.logService.error(`ChatSessionStore: ` + message, toErrorMessage(error));
+        const fileOperationReason = error && toFileOperationResult(error);
+        this.telemetryService.publicLog2('chatSessionStoreError', {
+            reason: reasonForTelemetry,
+            fileOperationReason: fileOperationReason ?? -1
+        });
+    }
+    internalGetIndex() {
+        if (this.indexCache) {
+            return this.indexCache;
+        }
+        const data = this.storageService.get(ChatIndexStorageKey, this.getIndexStorageScope(), undefined);
+        if (!data) {
+            this.indexCache = { version: 1, entries: {} };
+            return this.indexCache;
+        }
+        try {
+            const index = JSON.parse(data);
+            if (isChatSessionIndex(index)) {
+                this.indexCache = index;
+            }
+            else {
+                this.reportError('invalidIndexFormat', `Invalid index format: ${data}`);
+                this.indexCache = { version: 1, entries: {} };
+            }
+            return this.indexCache;
+        }
+        catch (e) {
+            this.reportError('invalidIndexJSON', `Index corrupt: ${data}`, e);
+            this.indexCache = { version: 1, entries: {} };
+            return this.indexCache;
+        }
+    }
+    async getIndex() {
+        return this.storeQueue.queue(async () => {
+            return this.internalGetIndex().entries;
+        });
+    }
+    logIndex() {
+        const data = this.storageService.get(ChatIndexStorageKey, this.getIndexStorageScope(), undefined);
+        this.logService.info('ChatSessionStore index: ', data);
+    }
+    async migrateDataIfNeeded(getInitialData) {
+        await this.storeQueue.queue(async () => {
+            const data = this.storageService.get(ChatIndexStorageKey, this.getIndexStorageScope(), undefined);
+            const needsMigrationFromStorageService = !data;
+            if (needsMigrationFromStorageService) {
+                const initialData = getInitialData();
+                if (initialData) {
+                    await this.migrate(initialData);
+                }
+            }
+        });
+    }
+    async migrate(initialData) {
+        const numSessions = ( Object.keys(initialData)).length;
+        this.logService.info(`ChatSessionStore: Migrating ${numSessions} chat sessions from storage service to file system`);
+        await Promise.all(( ( Object.values(initialData)).map(async (session) => {
+            await this.writeSession(session);
+        })));
+        await this.flushIndex();
+    }
+    async readSession(sessionId) {
+        return await this.storeQueue.queue(async () => {
+            let rawData;
+            const storageLocation = this.getStorageLocation(sessionId);
+            try {
+                rawData = ( (await this.fileService.readFile(storageLocation)).value.toString());
+            }
+            catch (e) {
+                this.reportError('sessionReadFile', `Error reading chat session file ${sessionId}`, e);
+                return undefined;
+            }
+            try {
+                const session = revive(JSON.parse(rawData));
+                for (const request of session.requests) {
+                    if (Array.isArray(request.response)) {
+                        request.response = ( request.response.map((response) => {
+                            if (typeof response === 'string') {
+                                return ( new MarkdownString(response));
+                            }
+                            return response;
+                        }));
+                    }
+                    else if (typeof request.response === 'string') {
+                        request.response = [( new MarkdownString(request.response))];
+                    }
+                }
+                return normalizeSerializableChatData(session);
+            }
+            catch (err) {
+                this.reportError('malformedSession', `Malformed session data in ${storageLocation.fsPath}: [${rawData.substring(0, 20)}${rawData.length > 20 ? '...' : ''}]`, err);
+                return undefined;
+            }
+        });
+    }
+    getStorageLocation(chatSessionId) {
+        return joinPath(this.storageRoot, `${chatSessionId}.json`);
+    }
+    getChatStorageFolder() {
+        return this.storageRoot;
+    }
+};
+ChatSessionStore = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IEnvironmentService)),
+    ( __param(2, ILogService)),
+    ( __param(3, IWorkspaceContextService)),
+    ( __param(4, ITelemetryService)),
+    ( __param(5, IStorageService)),
+    ( __param(6, ILifecycleService))
+], ChatSessionStore));
+function isChatSessionEntryMetadata(obj) {
+    return (!!obj &&
+        typeof obj === 'object' &&
+        typeof obj.sessionId === 'string' &&
+        typeof obj.title === 'string' &&
+        typeof obj.lastMessageDate === 'number');
+}
+function isChatSessionIndex(data) {
+    if (typeof data !== 'object' || data === null) {
+        return false;
+    }
+    const index = data;
+    if (index.version !== 1) {
+        return false;
+    }
+    if (typeof index.entries !== 'object' || index.entries === null) {
+        return false;
+    }
+    for (const key in index.entries) {
+        if (!isChatSessionEntryMetadata(index.entries[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+function getSessionMetadata(session) {
+    const title = session instanceof ChatModel ?
+        (session.title || ( localize(4987, "New Chat"))) :
+        session.customTitle ?? ChatModel.getDefaultTitle(session.requests);
+    return {
+        sessionId: session.sessionId,
+        title,
+        lastMessageDate: session.lastMessageDate,
+        isImported: session.isImported,
+        initialLocation: session.initialLocation,
+        isEmpty: session instanceof ChatModel ? session.getRequests().length === 0 : session.requests.length === 0
+    };
+}
+
+export { ChatSessionStore };

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 } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents";
+import { ChatAgentLocation, ChatMode } 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;
@@ -13,6 +13,7 @@ export interface IChatSlashData {
     sortText?: string;
     executeImmediately?: boolean;
     locations: ChatAgentLocation[];
+    modes?: ChatMode[];
 }
 export interface IChatSlashFragment {
     content: string | {
@@ -33,7 +34,7 @@ export declare class ChatSlashCommandService extends Disposable implements IChat
     constructor(_extensionService: IExtensionService);
     dispose(): void;
     registerSlashCommand(data: IChatSlashData, command: IChatSlashCallback): IDisposable;
-    getCommands(location: ChatAgentLocation): Array<IChatSlashData>;
+    getCommands(location: ChatAgentLocation, mode: ChatMode): 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/chatSlashCommands.js

@@ -28,8 +28,10 @@ let ChatSlashCommandService = class ChatSlashCommandService extends Disposable {
             }
         });
     }
-    getCommands(location) {
-        return Array.from(( this._commands.values()), v => v.data).filter(c => c.locations.includes(location));
+    getCommands(location, mode) {
+        return Array
+            .from(( this._commands.values()), v => v.data)
+            .filter(c => c.locations.includes(location) && (!c.modes || c.modes.includes(mode)));
     }
     hasCommand(id) {
         return ( this._commands.has(id));

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

@@ -0,0 +1,14 @@
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IWorkspaceTrustManagementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service";
+import { IChatTransferService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatTransferService.service";
+export declare class ChatTransferService implements IChatTransferService {
+    private readonly workspaceService;
+    private readonly storageService;
+    private readonly fileService;
+    private readonly workspaceTrustManagementService;
+    _serviceBrand: undefined;
+    constructor(workspaceService: IWorkspaceContextService, storageService: IStorageService, fileService: IFileService, workspaceTrustManagementService: IWorkspaceTrustManagementService);
+    checkAndSetWorkspaceTrust(): Promise<void>;
+}

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

@@ -0,0 +1,30 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IWorkspaceTrustManagementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
+import { isChatTransferredWorkspace, areWorkspaceFoldersEmpty } from '../../../services/workspaces/common/workspaceUtils.js';
+
+let ChatTransferService = class ChatTransferService {
+    constructor(workspaceService, storageService, fileService, workspaceTrustManagementService) {
+        this.workspaceService = workspaceService;
+        this.storageService = storageService;
+        this.fileService = fileService;
+        this.workspaceTrustManagementService = workspaceTrustManagementService;
+    }
+    async checkAndSetWorkspaceTrust() {
+        const workspace = this.workspaceService.getWorkspace();
+        if (isChatTransferredWorkspace(workspace, this.storageService) && (await areWorkspaceFoldersEmpty(workspace, this.fileService))) {
+            await this.workspaceTrustManagementService.setWorkspaceTrust(true);
+        }
+    }
+};
+ChatTransferService = ( __decorate([
+    ( __param(0, IWorkspaceContextService)),
+    ( __param(1, IStorageService)),
+    ( __param(2, IFileService)),
+    ( __param(3, IWorkspaceTrustManagementService))
+], ChatTransferService));
+
+export { ChatTransferService };

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

@@ -1,4 +1,3 @@
+import { LanguageFilter } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languageSelector";
 export declare const DOCUMENTATION_URL = "https://aka.ms/vscode-ghcp-prompt-snippets";
-export declare const LANGUAGE_SELECTOR: Readonly<{
-    pattern: "**/*.prompt.md";
-}>;
+export declare const LANGUAGE_SELECTOR: LanguageFilter;

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

@@ -1,9 +1,13 @@
 
-import { PROMPT_FILE_EXTENSION } from '@codingame/monaco-vscode-52bb4d5b-ba1a-57fd-9bee-b28824214eac-common/vscode/vs/platform/prompts/common/constants';
+import { PROMPT_FILE_EXTENSION, COPILOT_CUSTOM_INSTRUCTIONS_FILENAME } from '@codingame/monaco-vscode-a1eb43d5-da63-5f76-8ad4-acf0d6c3b749-common/vscode/vs/platform/prompts/common/constants';
 
 const DOCUMENTATION_URL = 'https://aka.ms/vscode-ghcp-prompt-snippets';
+const REUSABLE_PROMPT_FILE_PATTERNS = ( Object.freeze([
+    `**/*${PROMPT_FILE_EXTENSION}`,
+    `**/.github/${COPILOT_CUSTOM_INSTRUCTIONS_FILENAME}`,
+]));
 const LANGUAGE_SELECTOR = ( Object.freeze({
-    pattern: `**/*${PROMPT_FILE_EXTENSION}`,
+    pattern: `{${REUSABLE_PROMPT_FILE_PATTERNS.join(',')}}`,
 }));
 
 export { DOCUMENTATION_URL, LANGUAGE_SELECTOR };

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

@@ -1,13 +1,21 @@
+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 { VSBuffer } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buffer";
 import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
 import { PromptContentsProviderBase } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/contentProviders/promptContentsProviderBase";
 import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { ReadableStream } from "@codingame/monaco-vscode-api/vscode/vs/base/common/stream";
 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 { TextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model/textModel";
 export declare class TextModelContentsProvider extends PromptContentsProviderBase<IModelContentChangedEvent> {
     private readonly model;
-    readonly uri: import("@codingame/monaco-vscode-api/vscode/vs/base/common/uri").URI;
-    constructor(model: ITextModel);
+    private readonly initService;
+    readonly uri: URI;
+    constructor(model: ITextModel, initService: IInstantiationService);
     protected getContentsStream(_event: IModelContentChangedEvent | "full", cancellationToken?: CancellationToken): Promise<ReadableStream<VSBuffer>>;
+    createNew(promptContentsSource: TextModel | {
+        uri: URI;
+    }): IPromptContentsProvider;
     toString(): string;
 }

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

@@ -1,13 +1,19 @@
 
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
 import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { FilePromptContentProvider } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/contentProviders/filePromptContentsProvider';
 import { PromptContentsProviderBase } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/contentProviders/promptContentsProviderBase';
 import { newWriteableStream } from '@codingame/monaco-vscode-api/vscode/vs/base/common/stream';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { TextModel } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/textModel';
 
-class TextModelContentsProvider extends PromptContentsProviderBase {
-    constructor(model) {
+var TextModelContentsProvider_1;
+let TextModelContentsProvider = TextModelContentsProvider_1 = class TextModelContentsProvider extends PromptContentsProviderBase {
+    constructor(model, initService) {
         super();
         this.model = model;
+        this.initService = initService;
         this.uri = this.model.uri;
         this._register(this.model.onWillDispose(this.dispose.bind(this)));
         this._register(this.model.onDidChangeContent(this.onChangeEmitter.fire));
@@ -41,9 +47,18 @@ class TextModelContentsProvider extends PromptContentsProviderBase {
         }, 1);
         return stream;
     }
+    createNew(promptContentsSource) {
+        if (promptContentsSource instanceof TextModel) {
+            return this.initService.createInstance(TextModelContentsProvider_1, promptContentsSource);
+        }
+        return this.initService.createInstance(FilePromptContentProvider, promptContentsSource.uri);
+    }
     toString() {
         return `text-model-prompt-contents-provider:${this.uri.path}`;
     }
-}
+};
+TextModelContentsProvider = TextModelContentsProvider_1 = ( __decorate([
+    ( __param(1, IInstantiationService))
+], TextModelContentsProvider));
 
 export { TextModelContentsProvider };

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

@@ -0,0 +1,9 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+export declare class PromptLinkDiagnosticsInstanceManager extends Disposable {
+    private readonly providers;
+    constructor(editorService: IEditorService, initService: IInstantiationService, configService: IConfigurationService);
+    private handleNewEditor;
+}

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/languageFeatures/promptLinkDiagnosticsProvider.js

@@ -0,0 +1,117 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/types.service';
+import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { NotPromptFile } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/promptFileReferenceErrors';
+import { assertDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ObjectCache } from '../../../../../../base/common/objectCache.js';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { PromptsConfig } from '@codingame/monaco-vscode-a1eb43d5-da63-5f76-8ad4-acf0d6c3b749-common/vscode/vs/platform/prompts/common/config';
+import { isPromptFile } from '@codingame/monaco-vscode-a1eb43d5-da63-5f76-8ad4-acf0d6c3b749-common/vscode/vs/platform/prompts/common/constants';
+import { LifecyclePhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { ObservableDisposable } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/base/common/observableDisposable';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { MarkerSeverity } from '@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers';
+import { IMarkerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers.service';
+
+const MARKERS_OWNER_ID = 'reusable-prompts-syntax';
+let PromptLinkDiagnosticsProvider = class PromptLinkDiagnosticsProvider extends ObservableDisposable {
+    constructor(editor, markerService, promptsService) {
+        super();
+        this.editor = editor;
+        this.markerService = markerService;
+        this.promptsService = promptsService;
+        this.parser = this.promptsService
+            .getSyntaxParserFor(this.editor)
+            .onUpdate(this.updateMarkers.bind(this))
+            .onDispose(this.dispose.bind(this))
+            .start();
+        this.updateMarkers();
+    }
+    async updateMarkers() {
+        await this.parser.allSettled();
+        this.markerService.remove(MARKERS_OWNER_ID, [this.editor.uri]);
+        const markers = [];
+        for (const link of this.parser.references) {
+            const { topError, linkRange } = link;
+            if (!topError || !linkRange) {
+                continue;
+            }
+            const { originalError } = topError;
+            if (originalError instanceof NotPromptFile) {
+                continue;
+            }
+            markers.push(toMarker(link));
+        }
+        this.markerService.changeOne(MARKERS_OWNER_ID, this.editor.uri, markers);
+    }
+};
+PromptLinkDiagnosticsProvider = ( __decorate([
+    ( __param(1, IMarkerService)),
+    ( __param(2, IPromptsService))
+], PromptLinkDiagnosticsProvider));
+const toMarker = (link) => {
+    const { topError, linkRange } = link;
+    assertDefined(topError, 'Top error must to be defined.');
+    assertDefined(linkRange, 'Link range must to be defined.');
+    const { originalError } = topError;
+    assert(!(originalError instanceof NotPromptFile), 'Error must not be of "not prompt file" type.');
+    const severity = (topError.errorSubject === 'root')
+        ? MarkerSeverity.Error
+        : MarkerSeverity.Warning;
+    return {
+        message: topError.localizedMessage,
+        severity,
+        ...linkRange,
+    };
+};
+let PromptLinkDiagnosticsInstanceManager = class PromptLinkDiagnosticsInstanceManager extends Disposable {
+    constructor(editorService, initService, configService) {
+        super();
+        this.providers = this._register(( new ObjectCache((editor) => {
+            const parser = initService.createInstance(PromptLinkDiagnosticsProvider, editor);
+            parser.assertNotDisposed('Created prompt parser must not be disposed.');
+            return parser;
+        })));
+        if (!PromptsConfig.enabled(configService)) {
+            return;
+        }
+        this._register(editorService.onDidActiveEditorChange(() => {
+            const { activeTextEditorControl } = editorService;
+            if (!activeTextEditorControl) {
+                return;
+            }
+            this.handleNewEditor(activeTextEditorControl);
+        }));
+        editorService
+            .visibleTextEditorControls
+            .forEach(this.handleNewEditor.bind(this));
+    }
+    handleNewEditor(editor) {
+        const model = editor.getModel();
+        if (!model) {
+            return this;
+        }
+        if ('modified' in model || 'model' in model) {
+            return this;
+        }
+        if (!isPromptFile(model.uri)) {
+            return this;
+        }
+        this.providers.get(model);
+        return this;
+    }
+};
+PromptLinkDiagnosticsInstanceManager = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IConfigurationService))
+], PromptLinkDiagnosticsInstanceManager));
+( Registry.as(Extensions.Workbench))
+    .registerWorkbenchContribution(PromptLinkDiagnosticsInstanceManager, LifecyclePhase.Eventually);
+
+export { PromptLinkDiagnosticsInstanceManager };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/languageFeatures/promptPathAutocompletion.js

@@ -2,7 +2,6 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { LANGUAGE_SELECTOR } from '../constants.js';
 import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/types.service';
-import { FileReference } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/tokens/fileReference';
 import { assertOneOf } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { isWindows } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
@@ -22,7 +21,7 @@ const findFileReference = (references, position) => {
         if (reference.type !== 'file') {
             return undefined;
         }
-        if (!reference.text.startsWith(FileReference.TOKEN_START)) {
+        if (reference.subtype !== 'prompt') {
             return undefined;
         }
         const { startLineNumber, endColumn } = range;
@@ -96,10 +95,10 @@ let PromptPathAutocompletion = class PromptPathAutocompletion extends Disposable
     }
     async getFirstFolderSuggestions(character, fileFolderUri, fileReference) {
         const { linkRange } = fileReference;
-        if (character === ':' && linkRange !== undefined) {
+        if ((character === ':') && (linkRange !== undefined)) {
             return [];
         }
-        if (character === '.' && linkRange === undefined) {
+        if ((character === '.') && (linkRange === undefined)) {
             return [];
         }
         const suggestions = await this.getFolderSuggestions(fileFolderUri);