@vscode/chat-lib 0.0.1 → 0.0.2

package/src/_internal/platform/inlineEdits/common/workspaceEditTracker/historyContextProvider.ts

@@ -1,60 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { assert } from '../../../../util/vs/base/common/assert';
-import { OffsetRange } from '../../../../util/vs/editor/common/core/ranges/offsetRange';
-import { StringText } from '../../../../util/vs/editor/common/core/text/abstractText';
-import { DocumentId } from '../dataTypes/documentId';
-import { Edits, RootedEdit } from '../dataTypes/edit';
-import { LanguageId } from '../dataTypes/languageId';
-
-export interface IHistoryContextProvider {
-	/**
-	 * The result must contain a document with `docUri`.
-	*/
-	getHistoryContext(id: DocumentId): HistoryContext | undefined;
-}
-
-export class HistoryContext {
-	constructor(
-		/**
-		 * Sorted by time, from least recent to most recent.
-		*/
-		public readonly documents: readonly DocumentHistory[],
-	) {
-		assert(documents.length > 0);
-	}
-
-	getMostRecentDocument(): DocumentHistory {
-		return this.documents.at(-1)!;
-	}
-
-	getDocument(docId: DocumentId): DocumentHistory | undefined {
-		return this.documents.find(d => d.docId === docId);
-	}
-
-	getDocumentAndIdx(docId: DocumentId): { doc: DocumentHistory; idx: number } | undefined {
-		const idx = this.documents.findIndex(d => d.docId === docId);
-		if (idx === -1) { return undefined; }
-		return { doc: this.documents[idx], idx };
-	}
-}
-
-export class DocumentHistory {
-	public readonly lastEdit = new RootedEdit(this.base, this.lastEdits.compose());
-
-	constructor(
-		public readonly docId: DocumentId,
-		public readonly languageId: LanguageId,
-		public readonly base: StringText,
-		public readonly lastEdits: Edits,
-
-		/**
-		 * Refers to the state after edits
-		*/
-		public readonly lastSelection: OffsetRange | undefined,
-	) {
-	}
-}

package/src/_internal/platform/inlineEdits/common/workspaceEditTracker/nesHistoryContextProvider.ts

@@ -1,353 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { Disposable, toDisposable } from '../../../../util/vs/base/common/lifecycle';
-import { autorun, mapObservableArrayCached } from '../../../../util/vs/base/common/observable';
-import { assertType } from '../../../../util/vs/base/common/types';
-import { StringEdit } from '../../../../util/vs/editor/common/core/edits/stringEdit';
-import { TextEdit } from '../../../../util/vs/editor/common/core/edits/textEdit';
-import { OffsetRange } from '../../../../util/vs/editor/common/core/ranges/offsetRange';
-import { StringText } from '../../../../util/vs/editor/common/core/text/abstractText';
-import { DocumentId } from '../dataTypes/documentId';
-import { Edits, RootedEdit } from '../dataTypes/edit';
-import { LanguageId } from '../dataTypes/languageId';
-import { RootedLineEdit } from '../dataTypes/rootedLineEdit';
-import { TextLengthEdit } from '../dataTypes/textEditLength';
-import { ObservableGit } from '../observableGit';
-import { ObservableWorkspace } from '../observableWorkspace';
-import { autorunWithChanges } from '../utils/observable';
-import { Instant, now } from '../utils/utils';
-import { DocumentHistory, HistoryContext, IHistoryContextProvider } from './historyContextProvider';
-
-export class NesHistoryContextProvider extends Disposable implements IHistoryContextProvider {
-	private readonly _documentState = new Map<DocumentId, DocumentState>();
-	private readonly _lastDocuments = new FifoSet<DocumentState>(50);
-	private _lastGitCheckout: Instant | undefined;
-
-	constructor(workspace: ObservableWorkspace, observableGit: ObservableGit) {
-		super();
-
-		this._register(autorun(reader => {
-			const branch = reader.readObservable(observableGit.branch);
-			if (branch === undefined) {
-				return; // probably git extension hasn't activated or no repository found, so don't do anything
-			}
-			this._lastGitCheckout = now();
-			this._documentState.forEach(d => d.applyAllEdits());
-		}));
-
-		mapObservableArrayCached(this, workspace.openDocuments, (doc, store) => {
-			const initialSelection = doc.selection.get().at(0);
-			const state = new DocumentState(doc.id, doc.value.get().value, doc.languageId.get(), initialSelection);
-			this._documentState.set(state.docId, state);
-			if (initialSelection) {
-				this._lastDocuments.push(state);
-			}
-
-			store.add(autorunWithChanges(this, {
-				value: doc.value,
-				selection: doc.selection,
-				languageId: doc.languageId,
-			}, (data) => {
-				if (data.languageId.changes.length > 0) {
-					state.languageId = data.languageId.value;
-				}
-				const isInCooldown = this._isAwaitingGitCheckoutCooldown();
-				for (const edit of data.value.changes) {
-					this._lastDocuments.push(state);
-					state.handleEdit(edit, isInCooldown);
-				}
-				if (data.selection.changes.length > 0) {
-					state.handleSelection(data.selection.value.at(0));
-					this._lastDocuments.push(state);
-				}
-			}));
-
-			store.add(toDisposable(() => {
-				const state = this._documentState.get(doc.id);
-				if (state) {
-					this._lastDocuments.remove(state);
-				}
-				this._documentState.delete(doc.id);
-			}));
-		}, d => d.id).recomputeInitiallyAndOnChange(this._store);
-	}
-
-	public getHistoryContext(docId: DocumentId): HistoryContext | undefined {
-		const state = this._documentState.get(docId);
-		if (!state) {
-			return undefined;
-		}
-		if (!this._lastDocuments.has(state)) {
-			return undefined;
-		}
-
-		const docs: DocumentHistory[] = [];
-
-		let hasProcessedCurrentDocument = false;
-		let editCount = 5;
-
-		for (const doc of this._lastDocuments.getItemsReversed()) {
-			const result = doc.getRecentEdit(editCount);
-			if (result === undefined) { // result is undefined if the document is not a user document
-				continue;
-			}
-			if (result.editCount === 0 && hasProcessedCurrentDocument) {
-				break;
-			}
-			if (doc.docId === docId) {
-				hasProcessedCurrentDocument = true;
-			}
-			docs.push(result.history);
-			editCount -= result.editCount;
-			if (editCount <= 0) {
-				break;
-			}
-		}
-		docs.reverse();
-		// Docs is sorted from least recent to most recent now
-
-		if (!docs.some(d => d.docId === docId)) {
-			return undefined;
-		}
-
-		return new HistoryContext(docs);
-	}
-
-	private _isAwaitingGitCheckoutCooldown(): boolean {
-		if (!this._lastGitCheckout) {
-			return false;
-		}
-		const isInCooldown = now() - this._lastGitCheckout < 2 * 1000 /* 2 seconds */;
-		if (!isInCooldown) {
-			this._lastGitCheckout = undefined;
-		}
-		return isInCooldown;
-	}
-}
-
-class DocumentState {
-	private static readonly MAX_EDITED_LINES_PER_EDIT = 10;
-	private static readonly MAX_EDITED_CHARS_PER_EDIT = 5000;
-
-	private _baseValue: StringText;
-	private _currentValue: StringText;
-	private _edits: { edit: StringEdit; textLengthEdit: TextLengthEdit; instant: Instant }[] = [];
-	private _isUserDocument = false;
-	private _selection: OffsetRange | undefined;
-
-	constructor(
-		public readonly docId: DocumentId,
-		initialValue: string,
-		public languageId: LanguageId,
-		selection: OffsetRange | undefined,
-	) {
-		this._baseValue = new StringText(initialValue);
-		this._currentValue = this._baseValue;
-		this.handleSelection(selection);
-	}
-
-	public getSelection(): OffsetRange | undefined {
-		return this._selection;
-	}
-
-	public handleSelection(selection: OffsetRange | undefined): void {
-		if (selection) {
-			this._isUserDocument = true;
-		}
-		this._selection = selection;
-	}
-
-	public handleEdit(edit: StringEdit, isInCooldown: boolean): void {
-		if (edit.isEmpty()) {
-			return;
-		}
-
-		this._currentValue = edit.applyOnText(this._currentValue);
-		const textEdit = TextEdit.fromStringEdit(edit, this._currentValue);
-		const textLengthEdit = TextLengthEdit.fromTextEdit(textEdit);
-
-		if (isInCooldown) {
-			this._baseValue = this._currentValue;
-			this._edits = [];
-			return;
-		}
-
-		function editInsertSize(edit: StringEdit): number {
-			return sum(edit.replacements, e => e.newText.length);
-		}
-
-		const lastEdit = this._edits.at(-1);
-		if (lastEdit && editInsertSize(lastEdit.edit) < 200 && editExtends(edit, lastEdit.edit)) {
-			lastEdit.edit = lastEdit.edit.compose(edit);
-			lastEdit.textLengthEdit = lastEdit.textLengthEdit.compose(textLengthEdit);
-			lastEdit.instant = now();
-			if (lastEdit.edit.isEmpty()) {
-				this._edits.pop();
-			}
-		} else {
-			this._edits.push({ edit, textLengthEdit, instant: now() });
-		}
-	}
-
-	public getRecentEdit(maxEditCount: number): { history: DocumentHistory; editCount: number } | undefined {
-		if (!this._isUserDocument) {
-			return undefined;
-		}
-
-		// note that `editCount` may not match the actual number of edits in the history because it's computed by transforming to line edits
-		const { editCount } = this._applyStaleEdits(maxEditCount);
-
-		const edits = new Edits(StringEdit, this._edits.map(e => e.edit));
-
-		return {
-			history: new DocumentHistory(this.docId, this.languageId, this._baseValue, edits, this._selection),
-			editCount,
-		};
-	}
-
-	public applyAllEdits() {
-		this._baseValue = this._currentValue;
-		this._edits = [];
-	}
-
-	private _applyStaleEdits(maxEditCount: number): { editCount: number } {
-		let lastValue = this._currentValue;
-		let recentEdit: StringEdit = StringEdit.empty;
-		let recentTextLengthEdit = TextLengthEdit.empty;
-		let i: number;
-		let editCount = 0;
-		let mostRecentEdit: StringEdit = StringEdit.empty;
-
-		for (i = this._edits.length - 1; i >= 0; i--) {
-			const e = this._edits[i];
-
-			if (now() - e.instant > 10 * 60 * 1000) {
-				break;
-			}
-
-			const potentialNewTextLengthEdit = e.textLengthEdit.compose(recentTextLengthEdit);
-			const potentialNewRange = potentialNewTextLengthEdit.getRange();
-			// FIXME@ulugbekna: the code below can actually throw if one edit cancels another one out
-			assertType(potentialNewRange, 'we only compose non-empty Edits');
-			if (potentialNewRange.endLineNumber - potentialNewRange.startLineNumber > 100) {
-				break;
-			}
-
-			const changedLines = sum(e.textLengthEdit.edits, e => (e.range.endLineNumber - e.range.startLineNumber) + e.newLength.lineCount);
-			if (changedLines > DocumentState.MAX_EDITED_LINES_PER_EDIT) { // 5k line long -- it should work for both deletion & insertion
-				break;
-			}
-			const newCharacterCount = sum(e.edit.replacements, singleEdit => singleEdit.newText.length);
-			if (newCharacterCount > DocumentState.MAX_EDITED_CHARS_PER_EDIT) {
-				break;
-			}
-			const replacedCharacterCount = sum(e.edit.replacements, singleEdit => singleEdit.replaceRange.length);
-			if (replacedCharacterCount > DocumentState.MAX_EDITED_CHARS_PER_EDIT) {
-				break;
-			}
-
-			if (i === this._edits.length - 1) {
-				mostRecentEdit = e.edit;
-			} else {
-				const swapResult = StringEdit.trySwap(e.edit, mostRecentEdit);
-				if (swapResult) {
-					mostRecentEdit = swapResult.e1;
-				} else {
-					if (changedLines >= 2) {
-						// If the most recent edit (transformed to the current state) intersects with the current edit
-						// and the current edit is too big, composing them would hide the effect of the most recent edit
-						// relative to current edit. So, we stop here.
-						break;
-					}
-					mostRecentEdit = e.edit.compose(mostRecentEdit);
-				}
-			}
-
-			const inverseE = e.edit.inverse(lastValue.value);
-			lastValue = inverseE.applyOnText(lastValue);
-
-			const potentialRecentEdit = e.edit.compose(recentEdit);
-			const potentialLineEdit = RootedEdit.toLineEdit(new RootedEdit(lastValue, potentialRecentEdit));
-			const rootedLineEdit = new RootedLineEdit(lastValue, potentialLineEdit).removeCommonSuffixPrefixLines(); // do not take into account no-op edits
-			const editLineCount = rootedLineEdit.edit.replacements.length;
-			if (editLineCount > maxEditCount) {
-				break;
-			}
-
-			// We take the edit!
-			editCount = editLineCount;
-			recentEdit = potentialRecentEdit;
-			recentTextLengthEdit = potentialNewTextLengthEdit;
-		}
-
-		// remove & apply the edits we didn't take
-		for (let j = 0; j <= i; j++) {
-			const e = this._edits[j];
-			this._baseValue = e.edit.applyOnText(this._baseValue);
-		}
-
-		this._edits = this._edits.slice(i + 1);
-
-		return { editCount };
-	}
-
-	public toString(): string {
-		return new Edits(StringEdit, this._edits.map(e => e.edit)).toHumanReadablePatch(this._baseValue);
-	}
-}
-
-export function sum<T>(arr: readonly T[], f: (t: T) => number): number {
-	let result = 0;
-	for (const e of arr) {
-		result += f(e);
-	}
-	return result;
-}
-
-export function editExtends(edit: StringEdit, previousEdit: StringEdit): boolean {
-	const newRanges = previousEdit.getNewRanges();
-	return edit.replacements.every(e => doesTouch(e.replaceRange, newRanges));
-}
-
-function doesTouch(range: OffsetRange, sortedRanges: readonly OffsetRange[]) {
-	return sortedRanges.some(r => range.start === r.endExclusive || range.endExclusive === r.start);
-}
-
-class FifoSet<T> {
-	private _arr: T[] = [];
-
-	constructor(
-		public readonly maxSize: number
-	) {
-	}
-
-	push(e: T): void {
-		const existing = this._arr.indexOf(e);
-		if (existing !== -1) {
-			this._arr.splice(existing, 1);
-		} else if (this._arr.length >= this.maxSize) {
-			this._arr.shift();
-		}
-		this._arr.push(e);
-	}
-
-	remove(e: T): void {
-		const existing = this._arr.indexOf(e);
-		if (existing !== -1) {
-			this._arr.splice(existing, 1);
-		}
-	}
-
-	getItemsReversed(): readonly T[] {
-		const arr = [...this._arr];
-		arr.reverse();
-		return arr;
-	}
-
-	has(item: T): boolean {
-		return this._arr.indexOf(item) !== -1;
-	}
-}

package/src/_internal/platform/inlineEdits/common/workspaceEditTracker/nesXtabHistoryTracker.ts

@@ -1,176 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { assert } from '../../../../util/vs/base/common/assert';
-import { Disposable } from '../../../../util/vs/base/common/lifecycle';
-import { LinkedList } from '../../../../util/vs/base/common/linkedList';
-import { mapObservableArrayCached } from '../../../../util/vs/base/common/observable';
-import { StringEdit } from '../../../../util/vs/editor/common/core/edits/stringEdit';
-import { OffsetRange } from '../../../../util/vs/editor/common/core/ranges/offsetRange';
-import { StringText } from '../../../../util/vs/editor/common/core/text/abstractText';
-import { DocumentId } from '../dataTypes/documentId';
-import { RootedEdit } from '../dataTypes/edit';
-import { IObservableDocument, ObservableWorkspace } from '../observableWorkspace';
-import { autorunWithChanges } from '../utils/observable';
-
-export interface IXtabHistoryDocumentEntry {
-	docId: DocumentId;
-}
-
-export interface IXtabHistoryEditEntry extends IXtabHistoryDocumentEntry {
-	kind: 'edit';
-	edit: RootedEdit;
-}
-
-export interface IXtabHistoryVisibleRangesEntry extends IXtabHistoryDocumentEntry {
-	kind: 'visibleRanges';
-	visibleRanges: readonly OffsetRange[];
-	documentContent: StringText;
-}
-
-export type IXtabHistoryEntry =
-	| IXtabHistoryEditEntry
-	| IXtabHistoryVisibleRangesEntry
-
-type DocumentChangedEvent = {
-	value: StringText;
-	changes: StringEdit[];
-	previous: StringText | undefined;
-}
-
-type DocumentSelectionChangedEvent = {
-	value: readonly OffsetRange[];
-	changes: unknown[];
-	previous: readonly OffsetRange[] | undefined;
-}
-
-export class NesXtabHistoryTracker extends Disposable {
-
-	/** Max # of entries in history */
-	private static MAX_HISTORY_SIZE = 50;
-
-	private readonly idToEntry: Map<DocumentId, { entry: IXtabHistoryEntry; removeFromHistory: () => void }>;
-	private readonly history: LinkedList<IXtabHistoryEntry>;
-
-	constructor(workspace: ObservableWorkspace, private readonly maxHistorySize = NesXtabHistoryTracker.MAX_HISTORY_SIZE) {
-		super();
-
-		this.idToEntry = new Map();
-		this.history = new LinkedList();
-
-		mapObservableArrayCached(this, workspace.openDocuments, (doc, store) => {
-
-			// add .value to all observables
-			store.add(autorunWithChanges(this, {
-				rootedEdits: doc.value,
-				visibleRanges: doc.visibleRanges,
-			}, (data) => {
-
-				if (data.rootedEdits.changes.length > 0 && data.rootedEdits.previous !== undefined) {
-					this.handleEdits(doc, data.rootedEdits);
-				} else {
-					this.handleVisibleRangesChange(doc, data.visibleRanges);
-				}
-			}));
-
-		}, d => d.id).recomputeInitiallyAndOnChange(this._store);
-	}
-
-	getHistory(): IXtabHistoryEntry[] {
-		return [...this.history];
-	}
-
-	/**
-	 * If the document isn't already in history, add it to the history.
-	 * If the document is in history either with an edit or selection entry, do not include it again.
-	 */
-	private handleVisibleRangesChange(doc: IObservableDocument, visibleRangesChange: DocumentSelectionChangedEvent) {
-		if (visibleRangesChange.value.length === 0) {
-			return;
-		}
-
-		const previousRecord = this.idToEntry.get(doc.id);
-
-		// if this's an already known file
-		if (previousRecord !== undefined) {
-			// if it's an edit entry, do not change anything
-			if (previousRecord.entry.kind === 'edit') {
-				return;
-			}
-			// else remove from history to update the visible ranges
-			previousRecord.removeFromHistory();
-		}
-
-		const entry: IXtabHistoryEntry = { docId: doc.id, kind: 'visibleRanges', visibleRanges: visibleRangesChange.value, documentContent: doc.value.get() };
-		const removeFromHistory = this.history.push(entry);
-		this.idToEntry.set(doc.id, { entry, removeFromHistory });
-
-		this.compactHistory();
-	}
-
-	private handleEdits(doc: IObservableDocument, rootedEdits: DocumentChangedEvent) {
-		assert(rootedEdits.previous !== undefined, `Document has previous version`);
-		assert(rootedEdits.changes.length === 1, `Expected 1 edit change but got ${rootedEdits.changes.length}`);
-
-		const currentEdit = rootedEdits.changes[0];
-		if (currentEdit.replacements.length === 0) {
-			return;
-		}
-
-		const previousRecord = this.idToEntry.get(doc.id);
-
-		// const currentBase = rootedEdits.value.apply(currentEdit.inverseOnString(rootedEdits.previous.value));
-		const currentBase = rootedEdits.previous;
-		const currentRootedEdit = new RootedEdit(currentBase, currentEdit);
-
-		if (previousRecord === undefined) {
-			this.pushToHistory(doc.id, currentRootedEdit);
-			return;
-		}
-
-		if (previousRecord.entry.kind === 'visibleRanges') {
-			previousRecord.removeFromHistory();
-			this.pushToHistory(doc.id, currentRootedEdit);
-			return;
-		}
-
-		const lastRootedEdit = previousRecord.entry.edit;
-
-		const lastLineEdit = RootedEdit.toLineEdit(lastRootedEdit);
-
-		const currentLineEdit = RootedEdit.toLineEdit(currentRootedEdit);
-
-		if (!currentLineEdit.isEmpty() && !lastLineEdit.isEmpty() && lastLineEdit.replacements[0].lineRange.startLineNumber === currentLineEdit.replacements[0].lineRange.startLineNumber) {
-			// merge edits
-			previousRecord.removeFromHistory();
-			const composedEdit = lastRootedEdit.edit.compose(currentEdit);
-			const edit = new RootedEdit(lastRootedEdit.base, composedEdit);
-			this.pushToHistory(doc.id, edit);
-
-		} else {
-			this.pushToHistory(doc.id, currentRootedEdit);
-		}
-	}
-
-	private pushToHistory(docId: DocumentId, edit: RootedEdit) {
-		const entry: IXtabHistoryEntry = { docId, kind: 'edit', edit };
-		const removeFromHistory = this.history.push(entry);
-		this.idToEntry.set(docId, { entry, removeFromHistory });
-
-		this.compactHistory();
-	}
-
-	private compactHistory() {
-		if (this.history.size > this.maxHistorySize) {
-			const removedEntry = this.history.shift();
-			if (removedEntry !== undefined) {
-				const lastRecord = this.idToEntry.get(removedEntry.docId);
-				if (lastRecord !== undefined && removedEntry === lastRecord.entry) {
-					this.idToEntry.delete(removedEntry.docId);
-				}
-			}
-		}
-	}
-}

package/src/_internal/platform/languageContextProvider/common/languageContextProviderService.ts

@@ -1,25 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import type { CancellationToken, Disposable, TextDocument } from 'vscode';
-import { Copilot } from '../../../platform/inlineCompletions/common/api';
-import { createServiceIdentifier } from '../../../util/common/services';
-import { ContextItem } from '../../languageServer/common/languageContextService';
-
-export const ILanguageContextProviderService = createServiceIdentifier<ILanguageContextProviderService>('ILanguageContextProviderService');
-
-export interface ILanguageContextProviderService {
-	readonly _serviceBrand: undefined;
-
-	registerContextProvider<T extends Copilot.SupportedContextItem>(provider: Copilot.ContextProvider<T>): Disposable;
-
-	getAllProviders(): readonly Copilot.ContextProvider<Copilot.SupportedContextItem>[];
-
-	getContextProviders(doc: TextDocument): Copilot.ContextProvider<Copilot.SupportedContextItem>[];
-
-	getContextItems(doc: TextDocument, request: Copilot.ResolveRequest, cancellationToken: CancellationToken): AsyncIterable<ContextItem>;
-
-	getContextItemsOnTimeout(doc: TextDocument, request: Copilot.ResolveRequest): ContextItem[];
-}

package/src/_internal/platform/languageContextProvider/common/nullLanguageContextProviderService.ts

@@ -1,38 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import type { CancellationToken, TextDocument, Disposable as VscodeDisposable } from 'vscode';
-import { Copilot } from '../../../platform/inlineCompletions/common/api';
-import { Disposable } from '../../../util/vs/base/common/lifecycle';
-import { ContextItem } from '../../languageServer/common/languageContextService';
-import { ILanguageContextProviderService } from './languageContextProviderService';
-
-export class NullLanguageContextProviderService implements ILanguageContextProviderService {
-	_serviceBrand: undefined;
-
-	registerContextProvider<T extends Copilot.SupportedContextItem>(provider: Copilot.ContextProvider<T>): VscodeDisposable {
-		return Disposable.None;
-	}
-
-	getAllProviders(): readonly Copilot.ContextProvider<Copilot.SupportedContextItem>[] {
-		return [];
-	}
-
-	getContextProviders(doc: TextDocument): Copilot.ContextProvider<Copilot.SupportedContextItem>[] {
-		return [];
-	}
-
-	getContextItems(doc: TextDocument, request: Copilot.ResolveRequest, cancellationToken: CancellationToken): AsyncIterable<ContextItem> {
-		return {
-			[Symbol.asyncIterator]: async function* () {
-				// No context items to provide
-			}
-		};
-	}
-
-	getContextItemsOnTimeout(doc: TextDocument, request: Copilot.ResolveRequest): ContextItem[] {
-		return [];
-	}
-}