@codingame/monaco-vscode-api 13.1.6 → 14.0.0

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

@@ -0,0 +1,375 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { Disposable, dispose } from '../../../../base/common/lifecycle.js';
+import { walkTokens, lexer } from 'marked';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { annotateVulnerabilitiesInText } from './annotations.js';
+import { getFullyQualifiedId } from './chatAgents.js';
+import { IChatAgentNameService } from './chatAgents.service.js';
+import { ChatModelInitState } from './chatModel.js';
+import { countWords } from './chatWordCounter.js';
+import { hash } from '../../../../base/common/hash.js';
+
+function isRequestVM(item) {
+    return !!item && typeof item === 'object' && 'message' in item;
+}
+function isResponseVM(item) {
+    return !!item && typeof item.setVote !== 'undefined';
+}
+let ChatViewModel = class ChatViewModel extends Disposable {
+    get inputPlaceholder() {
+        return this._inputPlaceholder;
+    }
+    get model() {
+        return this._model;
+    }
+    setInputPlaceholder(text) {
+        this._inputPlaceholder = text;
+        this._onDidChange.fire({ kind: 'changePlaceholder' });
+    }
+    resetInputPlaceholder() {
+        this._inputPlaceholder = undefined;
+        this._onDidChange.fire({ kind: 'changePlaceholder' });
+    }
+    get sessionId() {
+        return this._model.sessionId;
+    }
+    get requestInProgress() {
+        return this._model.requestInProgress;
+    }
+    get requestPausibility() {
+        return this._model.requestPausibility;
+    }
+    get initState() {
+        return this._model.initState;
+    }
+    constructor(_model, codeBlockModelCollection, instantiationService) {
+        super();
+        this._model = _model;
+        this.codeBlockModelCollection = codeBlockModelCollection;
+        this.instantiationService = instantiationService;
+        this._onDidDisposeModel = this._register(( new Emitter()));
+        this.onDidDisposeModel = this._onDidDisposeModel.event;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._items = [];
+        this._inputPlaceholder = undefined;
+        _model.getRequests().forEach((request, i) => {
+            const requestModel = this.instantiationService.createInstance(ChatRequestViewModel, request);
+            this._items.push(requestModel);
+            this.updateCodeBlockTextModels(requestModel);
+            if (request.response) {
+                this.onAddResponse(request.response);
+            }
+        });
+        this._register(_model.onDidDispose(() => this._onDidDisposeModel.fire()));
+        this._register(_model.onDidChange(e => {
+            if (e.kind === 'addRequest') {
+                const requestModel = this.instantiationService.createInstance(ChatRequestViewModel, e.request);
+                this._items.push(requestModel);
+                this.updateCodeBlockTextModels(requestModel);
+                if (e.request.response) {
+                    this.onAddResponse(e.request.response);
+                }
+            }
+            else if (e.kind === 'addResponse') {
+                this.onAddResponse(e.response);
+            }
+            else if (e.kind === 'removeRequest') {
+                const requestIdx = this._items.findIndex(item => isRequestVM(item) && item.id === e.requestId);
+                if (requestIdx >= 0) {
+                    this._items.splice(requestIdx, 1);
+                }
+                const responseIdx = e.responseId && this._items.findIndex(item => isResponseVM(item) && item.id === e.responseId);
+                if (typeof responseIdx === 'number' && responseIdx >= 0) {
+                    const items = this._items.splice(responseIdx, 1);
+                    const item = items[0];
+                    if (item instanceof ChatResponseViewModel) {
+                        item.dispose();
+                    }
+                }
+            }
+            const modelEventToVmEvent = e.kind === 'addRequest' ? { kind: 'addRequest' }
+                : e.kind === 'initialize' ? { kind: 'initialize' }
+                    : e.kind === 'setHidden' ? { kind: 'setHidden' }
+                        : null;
+            this._onDidChange.fire(modelEventToVmEvent);
+        }));
+    }
+    onAddResponse(responseModel) {
+        const response = this.instantiationService.createInstance(ChatResponseViewModel, responseModel, this);
+        this._register(response.onDidChange(() => {
+            if (response.isComplete) {
+                this.updateCodeBlockTextModels(response);
+            }
+            return this._onDidChange.fire(null);
+        }));
+        this._items.push(response);
+        this.updateCodeBlockTextModels(response);
+    }
+    getItems() {
+        return this._items.filter((item) => !item.shouldBeRemovedOnSend);
+    }
+    dispose() {
+        super.dispose();
+        dispose(this._items.filter((item) => item instanceof ChatResponseViewModel));
+    }
+    updateCodeBlockTextModels(model) {
+        let content;
+        if (isRequestVM(model)) {
+            content = model.messageText;
+        }
+        else {
+            content = ( annotateVulnerabilitiesInText(model.response.value).map(x => x.content.value)).join('');
+        }
+        let codeBlockIndex = 0;
+        walkTokens(lexer(content), token => {
+            if (token.type === 'code') {
+                const lang = token.lang || '';
+                const text = token.text;
+                this.codeBlockModelCollection.update(this._model.sessionId, model, codeBlockIndex++, { text, languageId: lang, isComplete: true });
+            }
+        });
+    }
+};
+ChatViewModel = ( __decorate([
+    ( __param(2, IInstantiationService))
+], ChatViewModel));
+class ChatRequestViewModel {
+    get id() {
+        return this._model.id;
+    }
+    get dataId() {
+        return this.id + `_${ChatModelInitState[this._model.session.initState]}_${hash(this.variables)}_${hash(this.isComplete)}`;
+    }
+    get sessionId() {
+        return this._model.session.sessionId;
+    }
+    get username() {
+        return this._model.username;
+    }
+    get avatarIcon() {
+        return this._model.avatarIconUri;
+    }
+    get message() {
+        return this._model.message;
+    }
+    get messageText() {
+        return this.message.text;
+    }
+    get attempt() {
+        return this._model.attempt;
+    }
+    get variables() {
+        return this._model.variableData.variables;
+    }
+    get contentReferences() {
+        return this._model.response?.contentReferences;
+    }
+    get workingSet() {
+        return this._model.workingSet;
+    }
+    get confirmation() {
+        return this._model.confirmation;
+    }
+    get isComplete() {
+        return this._model.response?.isComplete ?? false;
+    }
+    get isCompleteAddedRequest() {
+        return this._model.isCompleteAddedRequest;
+    }
+    get shouldBeRemovedOnSend() {
+        return this._model.shouldBeRemovedOnSend;
+    }
+    get slashCommand() {
+        return this._model.response?.slashCommand;
+    }
+    get agentOrSlashCommandDetected() {
+        return this._model.response?.agentOrSlashCommandDetected ?? false;
+    }
+    constructor(_model) {
+        this._model = _model;
+    }
+}
+let ChatResponseViewModel = class ChatResponseViewModel extends Disposable {
+    get model() {
+        return this._model;
+    }
+    get id() {
+        return this._model.id;
+    }
+    get dataId() {
+        return this._model.id +
+            `_${this._modelChangeCount}` +
+            `_${ChatModelInitState[this._model.session.initState]}` +
+            (this.isLast ? '_last' : '');
+    }
+    get sessionId() {
+        return this._model.session.sessionId;
+    }
+    get username() {
+        if (this.agent) {
+            const isAllowed = this.chatAgentNameService.getAgentNameRestriction(this.agent);
+            if (isAllowed) {
+                return this.agent.fullName || this.agent.name;
+            }
+            else {
+                return getFullyQualifiedId(this.agent);
+            }
+        }
+        return this._model.username;
+    }
+    get avatarIcon() {
+        return this._model.avatarIcon;
+    }
+    get agent() {
+        return this._model.agent;
+    }
+    get slashCommand() {
+        return this._model.slashCommand;
+    }
+    get agentOrSlashCommandDetected() {
+        return this._model.agentOrSlashCommandDetected;
+    }
+    get response() {
+        return this._model.response;
+    }
+    get usedContext() {
+        return this._model.usedContext;
+    }
+    get contentReferences() {
+        return this._model.contentReferences;
+    }
+    get codeCitations() {
+        return this._model.codeCitations;
+    }
+    get progressMessages() {
+        return this._model.progressMessages;
+    }
+    get isComplete() {
+        return this._model.isComplete;
+    }
+    get isCanceled() {
+        return this._model.isCanceled;
+    }
+    get shouldBeRemovedOnSend() {
+        return this._model.shouldBeRemovedOnSend;
+    }
+    get isCompleteAddedRequest() {
+        return this._model.isCompleteAddedRequest;
+    }
+    get replyFollowups() {
+        return this._model.followups?.filter((f) => f.kind === 'reply');
+    }
+    get result() {
+        return this._model.result;
+    }
+    get errorDetails() {
+        return this.result?.errorDetails;
+    }
+    get vote() {
+        return this._model.vote;
+    }
+    get voteDownReason() {
+        return this._model.voteDownReason;
+    }
+    get requestId() {
+        return this._model.requestId;
+    }
+    get isStale() {
+        return this._model.isStale;
+    }
+    get isLast() {
+        return this._chatViewModel.getItems().at(-1) === this;
+    }
+    get usedReferencesExpanded() {
+        if (typeof this._usedReferencesExpanded === 'boolean') {
+            return this._usedReferencesExpanded;
+        }
+        return this.response.value.length === 0 && !this.errorDetails;
+    }
+    set usedReferencesExpanded(v) {
+        this._usedReferencesExpanded = v;
+    }
+    get vulnerabilitiesListExpanded() {
+        return this._vulnerabilitiesListExpanded;
+    }
+    set vulnerabilitiesListExpanded(v) {
+        this._vulnerabilitiesListExpanded = v;
+    }
+    get contentUpdateTimings() {
+        return this._contentUpdateTimings;
+    }
+    constructor(_model, _chatViewModel, logService, chatAgentNameService) {
+        super();
+        this._model = _model;
+        this._chatViewModel = _chatViewModel;
+        this.logService = logService;
+        this.chatAgentNameService = chatAgentNameService;
+        this._modelChangeCount = 0;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this.renderData = undefined;
+        this._vulnerabilitiesListExpanded = false;
+        this._contentUpdateTimings = undefined;
+        if (!_model.isComplete) {
+            this._contentUpdateTimings = {
+                totalTime: 0,
+                lastUpdateTime: Date.now(),
+                impliedWordLoadRate: 0,
+                lastWordCount: 0,
+            };
+        }
+        this._register(_model.onDidChange(() => {
+            if (this._contentUpdateTimings) {
+                const now = Date.now();
+                const wordCount = countWords(_model.response.getMarkdown());
+                if (wordCount > 0 && wordCount === this._contentUpdateTimings.lastWordCount) {
+                    this.trace('onDidChange', `Update- no new words`);
+                }
+                else {
+                    const timeDiff = Math.min(now - this._contentUpdateTimings.lastUpdateTime, 1000);
+                    const newTotalTime = Math.max(this._contentUpdateTimings.totalTime + timeDiff, 250);
+                    const impliedWordLoadRate = this._contentUpdateTimings.lastWordCount / (newTotalTime / 1000);
+                    this.trace('onDidChange', `Update- got ${this._contentUpdateTimings.lastWordCount} words over last ${newTotalTime}ms = ${impliedWordLoadRate} words/s. ${wordCount} words are now available.`);
+                    this._contentUpdateTimings = {
+                        totalTime: this._contentUpdateTimings.totalTime !== 0 || ( this.response.value.some(v => v.kind === 'markdownContent')) ?
+                            newTotalTime :
+                            this._contentUpdateTimings.totalTime,
+                        lastUpdateTime: now,
+                        impliedWordLoadRate,
+                        lastWordCount: wordCount
+                    };
+                }
+            }
+            else {
+                this.logService.warn('ChatResponseViewModel#onDidChange: got model update but contentUpdateTimings is not initialized');
+            }
+            this._modelChangeCount++;
+            this._onDidChange.fire();
+        }));
+    }
+    trace(tag, message) {
+        this.logService.trace(`ChatResponseViewModel#${tag}: ${message}`);
+    }
+    setVote(vote) {
+        this._modelChangeCount++;
+        this._model.setVote(vote);
+    }
+    setVoteDownReason(reason) {
+        this._modelChangeCount++;
+        this._model.setVoteDownReason(reason);
+    }
+    setEditApplied(edit, editCount) {
+        this._modelChangeCount++;
+        this._model.setEditApplied(edit, editCount);
+    }
+};
+ChatResponseViewModel = ( __decorate([
+    ( __param(2, ILogService)),
+    ( __param(3, IChatAgentNameService))
+], ChatResponseViewModel));
+
+export { ChatRequestViewModel, ChatResponseViewModel, ChatViewModel, isRequestVM, isResponseVM };

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

@@ -1,6 +1,6 @@
 import { Event } from "../../../../base/common/event.js";
 import { ChatAgentLocation } from "./chatAgents.js";
-import { IChatHistoryEntry } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/chatWidgetHistoryService";
+import { IChatHistoryEntry } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/chatWidgetHistoryService";
 export declare const IChatWidgetHistoryService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatWidgetHistoryService>;
 export interface IChatWidgetHistoryService {
     _serviceBrand: undefined;

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

@@ -0,0 +1,8 @@
+export interface IWordCountResult {
+    value: string;
+    returnedWordCount: number;
+    totalWordCount: number;
+    isFullString: boolean;
+}
+export declare function getNWords(str: string, numWordsToCount: number): IWordCountResult;
+export declare function countWords(str: string): number;

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

@@ -0,0 +1,38 @@
+
+
+const r = String.raw;
+const linkPattern = r `(?<!\\)` +
+    r `(!?\[` +
+     r `(?:` +
+     r `[^\[\]\\]|` +
+     r `\\.|` +
+     r `\[[^\[\]]*\]` +
+     r `)*` +
+    r `\])` +
+    r `(\(\s*)` +
+     r `(` +
+     r `[^\s\(\)<](?:[^\s\(\)]|\([^\s\(\)]*?\))*|` +
+     r `<(?:\\[<>]|[^<>])+>` +
+     r `)` +
+     r `\s*(?:"[^"]*"|'[^']*'|\([^\(\)]*\))?\s*` +
+    r `\)`;
+function getNWords(str, numWordsToCount) {
+    const allWordMatches = Array.from(str.matchAll(( new RegExp(linkPattern + r `|\p{sc=Han}|=+|\++|-+|[^\s\|\p{sc=Han}|=|\+|\-]+`, 'gu'))));
+    const targetWords = allWordMatches.slice(0, numWordsToCount);
+    const endIndex = numWordsToCount >= allWordMatches.length
+        ? str.length
+        : targetWords.length ? targetWords.at(-1).index + targetWords.at(-1)[0].length : 0;
+    const value = str.substring(0, endIndex);
+    return {
+        value,
+        returnedWordCount: targetWords.length === 0 ? (value.length ? 1 : 0) : targetWords.length,
+        isFullString: endIndex >= str.length,
+        totalWordCount: allWordMatches.length
+    };
+}
+function countWords(str) {
+    const result = getNWords(str, Number.MAX_SAFE_INTEGER);
+    return result.returnedWordCount;
+}
+
+export { countWords, getNWords };

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

@@ -0,0 +1,12 @@
+import { Disposable } from "../../../../base/common/lifecycle.js";
+import { IStorageService } from "../../../../platform/storage/common/storage.service.js";
+import { ExtensionIdentifier } from "../../../../platform/extensions/common/extensions.js";
+import { IExtensionFeaturesManagementService } from "../../../services/extensionManagement/common/extensionFeatures.service.js";
+import { ILanguageModelStatsService } from "./languageModelStats.service.js";
+export declare class LanguageModelStatsService extends Disposable implements ILanguageModelStatsService {
+    private readonly extensionFeaturesManagementService;
+    _serviceBrand: undefined;
+    constructor(extensionFeaturesManagementService: IExtensionFeaturesManagementService, storageService: IStorageService);
+    update(model: string, extensionId: ExtensionIdentifier, agent: string | undefined, tokenCount: number | undefined): Promise<void>;
+}
+export declare const CopilotUsageExtensionFeatureId = "copilot";

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

@@ -0,0 +1,42 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
+import { Extensions } from '../../../services/extensionManagement/common/extensionFeatures.js';
+import { IExtensionFeaturesManagementService } from '../../../services/extensionManagement/common/extensionFeatures.service.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { localize } from '../../../../nls.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+
+let LanguageModelStatsService = class LanguageModelStatsService extends Disposable {
+    constructor(extensionFeaturesManagementService, storageService) {
+        super();
+        this.extensionFeaturesManagementService = extensionFeaturesManagementService;
+        for (const key in ( storageService.keys(StorageScope.APPLICATION, StorageTarget.USER))) {
+            if (key.startsWith('languageModelStats.') || key.startsWith('languageModelAccess.')) {
+                storageService.remove(key, StorageScope.APPLICATION);
+            }
+        }
+    }
+    async update(model, extensionId, agent, tokenCount) {
+        await this.extensionFeaturesManagementService.getAccess(extensionId, CopilotUsageExtensionFeatureId);
+    }
+};
+LanguageModelStatsService = ( __decorate([
+    ( __param(0, IExtensionFeaturesManagementService)),
+    ( __param(1, IStorageService))
+], LanguageModelStatsService));
+const CopilotUsageExtensionFeatureId = 'copilot';
+( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
+    id: CopilotUsageExtensionFeatureId,
+    label: ( localize(4759, "Copilot")),
+    description: ( localize(4760, "Language models usage statistics of this extension.")),
+    icon: Codicon.copilot,
+    access: {
+        canToggle: false
+    },
+    accessDataLabel: ( localize(4761, "chat")),
+});
+
+export { CopilotUsageExtensionFeatureId, LanguageModelStatsService };

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

@@ -27,6 +27,7 @@ export interface IToolInvocation {
     parameters: Object;
     tokenBudget?: number;
     context: IToolInvocationContext | undefined;
+    chatRequestId?: string;
 }
 export interface IToolInvocationContext {
     sessionId: string;
@@ -49,6 +50,8 @@ export interface IToolConfirmationMessages {
 }
 export interface IPreparedToolInvocation {
     invocationMessage?: string | IMarkdownString;
+    pastTenseMessage?: string | IMarkdownString;
+    tooltip?: string | IMarkdownString;
     confirmationMessages?: IToolConfirmationMessages;
 }
 export interface IToolImpl {

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

@@ -12,4 +12,5 @@ export interface ILanguageModelToolsService {
     getTool(id: string): IToolData | undefined;
     getToolByName(name: string): IToolData | undefined;
     invokeTool(invocation: IToolInvocation, countTokens: CountTokensCallback, token: CancellationToken): Promise<IToolResult>;
+    cancelToolCallsForRequest(requestId: string): void;
 }

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

@@ -62,6 +62,10 @@ export interface ILanguageModelChatMetadata {
         readonly providerLabel: string;
         readonly accountLabel?: string;
     };
+    readonly capabilities?: {
+        readonly vision?: boolean;
+        readonly toolCalling?: boolean;
+    };
 }
 export interface ILanguageModelChatResponse {
     stream: AsyncIterable<IChatResponseFragment>;
@@ -76,18 +80,19 @@ export interface ILanguageModelChat {
 }
 export interface ILanguageModelChatSelector {
     readonly name?: string;
-    readonly identifier?: string;
+    readonly id?: string;
     readonly vendor?: string;
     readonly version?: string;
     readonly family?: string;
     readonly tokens?: number;
     readonly extension?: ExtensionIdentifier;
 }
+export interface ILanguageModelChatMetadataAndIdentifier {
+    metadata: ILanguageModelChatMetadata;
+    identifier: string;
+}
 export interface ILanguageModelsChangeEvent {
-    added?: {
-        identifier: string;
-        metadata: ILanguageModelChatMetadata;
-    }[];
+    added?: ILanguageModelChatMetadataAndIdentifier[];
     removed?: string[];
 }
 interface IUserFriendlyLanguageModel {

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

@@ -24,14 +24,14 @@ const languageModelType = {
     properties: {
         vendor: {
             type: 'string',
-            description: ( localize(4640, "A globally unique vendor of language models."))
+            description: ( localize(4762, "A globally unique vendor of language models."))
         }
     }
 };
 const languageModelExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'languageModels',
     jsonSchema: {
-        description: ( localize(4641, "Contribute language models of a specific vendor.")),
+        description: ( localize(4763, "Contribute language models of a specific vendor.")),
         oneOf: [
             languageModelType,
             {
@@ -61,24 +61,24 @@ let LanguageModelsService = class LanguageModelsService {
             this._vendors.clear();
             for (const extension of extensions) {
                 if (!isProposedApiEnabled(extension.description, 'chatProvider')) {
-                    extension.collector.error(( localize(4642, "This contribution point requires the 'chatProvider' proposal.")));
+                    extension.collector.error(( localize(4764, "This contribution point requires the 'chatProvider' proposal.")));
                     continue;
                 }
                 for (const item of Iterable.wrap(extension.value)) {
                     if (( this._vendors.has(item.vendor))) {
                         extension.collector.error(( localize(
-                            4643,
+                            4765,
                             "The vendor '{0}' is already registered and cannot be registered twice",
                             item.vendor
                         )));
                         continue;
                     }
                     if (isFalsyOrWhitespace(item.vendor)) {
-                        extension.collector.error(( localize(4644, "The vendor field cannot be empty.")));
+                        extension.collector.error(( localize(4766, "The vendor field cannot be empty.")));
                         continue;
                     }
                     if (item.vendor.trim() !== item.vendor) {
-                        extension.collector.error(( localize(4645, "The vendor field cannot start or end with whitespace.")));
+                        extension.collector.error(( localize(4767, "The vendor field cannot start or end with whitespace.")));
                         continue;
                     }
                     this._vendors.add(item.vendor);
@@ -121,7 +121,7 @@ let LanguageModelsService = class LanguageModelsService {
             if ((selector.vendor === undefined || model.metadata.vendor === selector.vendor)
                 && (selector.family === undefined || model.metadata.family === selector.family)
                 && (selector.version === undefined || model.metadata.version === selector.version)
-                && (selector.identifier === undefined || model.metadata.id === selector.identifier)
+                && (selector.id === undefined || model.metadata.id === selector.id)
                 && (!model.metadata.targetExtensions || ( model.metadata.targetExtensions.some(candidate => ExtensionIdentifier.equals(candidate, selector.extension))))) {
                 result.push(identifier);
             }

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

@@ -0,0 +1,9 @@
+import { URI } from "../../../../../../base/common/uri.js";
+import { ParseError } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/promptFileReferenceErrors";
+import { IDisposable } from "../../../../../../base/common/lifecycle.js";
+import { VSBufferReadableStream } from "../../../../../../base/common/buffer.js";
+export interface IPromptContentsProvider extends IDisposable {
+    readonly uri: URI;
+    start(): this;
+    onContentChanged(callback: (streamOrError: VSBufferReadableStream | ParseError) => void): IDisposable;
+}

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

@@ -0,0 +1,27 @@
+import { URI } from "../../../../../../base/common/uri.js";
+import { ParseError } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/promptFileReferenceErrors";
+import { IDisposable } from "../../../../../../base/common/lifecycle.js";
+import { IRange, Range } from "../../../../../../editor/common/core/range.js";
+export interface IResolveError {
+    message: string;
+    isRootError: boolean;
+}
+type PromptReferenceTypes = "file";
+export interface IPromptReference extends IDisposable {
+    readonly type: PromptReferenceTypes;
+    readonly uri: URI;
+    readonly range: Range;
+    readonly linkRange: IRange | undefined;
+    readonly isPromptSnippet: boolean;
+    readonly resolveFailed: boolean | undefined;
+    readonly errorCondition: ParseError | undefined;
+    readonly allErrors: readonly ParseError[];
+    readonly topError: IResolveError | undefined;
+    allReferences: readonly IPromptReference[];
+    allValidReferences: readonly IPromptReference[];
+    settled(): Promise<this>;
+    allSettled(): Promise<this>;
+}
+export interface IPromptFileReference extends IPromptReference {
+    readonly type: "file";
+}