@vscode/chat-lib 0.0.1 → 0.0.2

package/src/_internal/platform/parser/node/nodes.ts

@@ -1,190 +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 { Point, SyntaxNode } from 'web-tree-sitter';
-import { BugIndicatingError } from '../../../util/vs/base/common/errors';
-import { Range, Uri } from '../../../util/common/test/shims/vscodeTypesShim';
-export interface TreeSitterOffsetRange {
-	startIndex: number;
-	endIndex: number;
-}
-
-export interface TreeSitterExpressionInfo extends TreeSitterOffsetRange {
-	version?: number;
-	identifier: string;
-	text: string;
-}
-
-export interface TreeSitterExpressionLocationInfo extends TreeSitterOffsetRange {
-	text: string;
-	version?: number;
-	uri?: Uri;
-	range?: Range;
-	identifier?: string;
-}
-
-export interface TreeSitterPoint {
-	row: number;
-	column: number;
-}
-
-export interface TreeSitterPointRange {
-	startPosition: TreeSitterPoint;
-	endPosition: TreeSitterPoint;
-}
-
-/** Util functions to deal with `TreeSitterOffsetRange` type */
-export const TreeSitterOffsetRange = {
-	/** check if `container` contains `containee` (non-strict, ie [0, 3] contains [0, 3] */
-	doesContain: (container: TreeSitterOffsetRange, containee: TreeSitterOffsetRange): boolean => container.startIndex <= containee.startIndex && containee.endIndex <= container.endIndex,
-
-	ofSyntaxNode: (n: SyntaxNode): TreeSitterOffsetRange => ({ startIndex: n.startIndex, endIndex: n.endIndex }),
-
-	/** sort by `node.startIndex`, break ties by `node.endIndex` (so that nodes with same start index are sorted in descending order) */
-	compare: (a: TreeSitterOffsetRange, b: TreeSitterOffsetRange): number => a.startIndex - b.startIndex || b.endIndex - a.endIndex,
-	isEqual: (a: TreeSitterOffsetRange, b: TreeSitterOffsetRange): boolean => TreeSitterOffsetRange.compare(a, b) === 0,
-
-	doIntersect: (a: TreeSitterOffsetRange, b: TreeSitterOffsetRange) => {
-		const start = Math.max(a.startIndex, b.startIndex);
-		const end = Math.min(a.endIndex, b.endIndex);
-		return start < end;
-	},
-
-	len: (n: TreeSitterOffsetRange) => n.endIndex - n.startIndex,
-
-	/** Given offset ranges [a0, a1] and [b0, b1], returns overlap size */
-	intersectionSize: (a: TreeSitterOffsetRange, b: TreeSitterOffsetRange): number => {
-		const start = Math.max(a.startIndex, b.startIndex);
-		const end = Math.min(a.endIndex, b.endIndex);
-		return Math.max(end - start, 0);
-	},
-
-	/** Check the given object extends TreeSitterOffsetRange  */
-	isTreeSitterOffsetRange(obj: any): obj is TreeSitterOffsetRange {
-		return typeof obj.startIndex === 'number' && typeof obj.endIndex === 'number';
-	},
-};
-
-export const TreeSitterPoint = {
-
-	isEqual(n: TreeSitterPoint, other: TreeSitterPoint): boolean {
-		return n.row === other.row && n.column === other.column;
-	},
-
-	isBefore(n: TreeSitterPoint, other: TreeSitterPoint): boolean {
-		if (n.row < other.row || (n.row === other.row && n.column < other.column)) {
-			return true;
-		}
-		return false;
-	},
-
-	isAfter(n: TreeSitterPoint, other: TreeSitterPoint): boolean {
-		return TreeSitterPoint.isBefore(other, n);
-	},
-
-	isBeforeOrEqual(n: TreeSitterPoint, other: TreeSitterPoint): boolean {
-		const isBefore = TreeSitterPoint.isBefore(n, other);
-		const isEqual = TreeSitterPoint.isEqual(n, other);
-		if (isBefore || isEqual) {
-			return true;
-		}
-		return false;
-	},
-
-	equals(n: TreeSitterPoint, other: TreeSitterPoint): boolean {
-		return n.column === other.column && n.row === other.row;
-	},
-
-	isAfterOrEqual(n: TreeSitterPoint, other: TreeSitterPoint): boolean {
-		return TreeSitterPoint.isBeforeOrEqual(other, n);
-	},
-
-	ofPoint: (n: Point): TreeSitterPoint => ({
-		row: n.row,
-		column: n.column
-	}),
-};
-
-export const TreeSitterPointRange = {
-
-	/** check if `container` contains `containee` (non-strict) */
-	doesContain: (container: TreeSitterPointRange, containee: TreeSitterPointRange): boolean => {
-		return TreeSitterPoint.isBeforeOrEqual(container.startPosition, containee.startPosition) && TreeSitterPoint.isAfterOrEqual(container.endPosition, containee.endPosition);
-	},
-
-	equals: (a: TreeSitterPointRange, b: TreeSitterPointRange): boolean => {
-		return TreeSitterPoint.equals(a.startPosition, b.startPosition) && TreeSitterPoint.equals(a.endPosition, b.endPosition);
-	},
-
-	ofSyntaxNode: (n: SyntaxNode): TreeSitterPointRange => ({
-		startPosition: n.startPosition,
-		endPosition: n.endPosition
-	}),
-};
-
-export interface Node extends TreeSitterOffsetRange {
-	type: string;
-}
-
-export const Node = {
-	ofSyntaxNode: (n: SyntaxNode) => ({
-		type: n.type,
-		startIndex: n.startIndex,
-		endIndex: n.endIndex,
-	}),
-};
-
-export interface TreeSitterChunkHeaderInfo extends TreeSitterOffsetRange {
-	text: string;
-	range: TreeSitterPointRange;
-}
-
-export const TreeSitterChunkHeaderInfo = {
-	ofSyntaxNode: (n: SyntaxNode): TreeSitterChunkHeaderInfo => ({
-		range: TreeSitterPointRange.ofSyntaxNode(n),
-		startIndex: n.startIndex,
-		text: n.text,
-		endIndex: n.endIndex,
-	}),
-};
-
-/**
- * Represents a node in the overlay tree.
- */
-export class OverlayNode {
-	constructor(
-		public readonly startIndex: number,
-		public readonly endIndex: number,
-		/**
-		 * @example `class_declaration`
-		 */
-		public kind: string, // TODO@ulugbekna: come up with more generic kinds so that these aren't per-language, then use enum?
-		public readonly children: OverlayNode[],
-	) {
-		if (startIndex > endIndex) {
-			throw new BugIndicatingError('startIndex must be less than endIndex');
-		}
-		let minStartIndex = startIndex;
-		for (const child of children) {
-			if (child.startIndex < minStartIndex) {
-				throw new BugIndicatingError('Invalid child startIndex');
-			}
-			if (child.endIndex > endIndex) {
-				throw new BugIndicatingError('Invalid child endIndex');
-			}
-			minStartIndex = Math.max(child.endIndex, minStartIndex);
-		}
-	}
-
-	toString() {
-		const printedNodes: string[] = [];
-		function toString(node: OverlayNode, indent = '') {
-			printedNodes.push(`${indent}${node.kind} [${node.startIndex}, ${node.endIndex}]`);
-			node.children.forEach(child => toString(child, indent + '    '));
-		}
-		toString(this);
-		return printedNodes.join('\n');
-	}
-}

package/src/_internal/platform/requestLogger/node/nullRequestLogger.ts

@@ -1,26 +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 { RequestMetadata } from '@vscode/copilot-api';
-import type { LanguageModelToolResult } from 'vscode';
-import { AbstractRequestLogger, ILoggedRequestInfo, LoggedRequest } from '../../../platform/requestLogger/node/requestLogger';
-import { Event } from '../../../util/vs/base/common/event';
-import { IModelAPIResponse } from '../../endpoint/common/endpointProvider';
-
-export class NullRequestLogger extends AbstractRequestLogger {
-	public override addPromptTrace(): void {
-	}
-	public addEntry(entry: LoggedRequest): void {
-	}
-	public override getRequests(): ILoggedRequestInfo[] {
-		return [];
-	}
-	public override logModelListCall(id: string, requestMetadata: RequestMetadata, models: IModelAPIResponse[]): void {
-
-	}
-	public override logToolCall(name: string | undefined, args: unknown, response: LanguageModelToolResult): void {
-	}
-	override onDidChangeRequests: Event<void> = Event.None;
-}

package/src/_internal/platform/requestLogger/node/requestLogger.ts

@@ -1,383 +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 { RequestMetadata } from '@vscode/copilot-api';
-import { HTMLTracer, IChatEndpointInfo, Raw, RenderPromptResult } from '@vscode/prompt-tsx';
-import { AsyncLocalStorage } from 'async_hooks';
-import type { Event } from 'vscode';
-import { ChatFetchError, ChatFetchResponseType, ChatLocation, ChatResponses, FetchSuccess } from '../../../platform/chat/common/commonTypes';
-import { IResponseDelta, OpenAiFunctionTool, OpenAiResponsesFunctionTool, OptionalChatRequestParams } from '../../../platform/networking/common/fetch';
-import { IChatEndpoint, IEndpointBody } from '../../../platform/networking/common/networking';
-import { Result } from '../../../util/common/result';
-import { createServiceIdentifier } from '../../../util/common/services';
-import { Disposable } from '../../../util/vs/base/common/lifecycle';
-import { ThemeIcon } from '../../../util/vs/base/common/themables';
-import { assertType } from '../../../util/vs/base/common/types';
-import { OffsetRange } from '../../../util/vs/editor/common/core/ranges/offsetRange';
-import type { ChatRequest, LanguageModelToolResult2 } from '../../../vscodeTypes';
-import type { IModelAPIResponse } from '../../endpoint/common/endpointProvider';
-import { Completion } from '../../nesFetch/common/completionsAPI';
-import { CompletionsFetchFailure, ModelParams } from '../../nesFetch/common/completionsFetchService';
-import { IFetchRequestParams } from '../../nesFetch/node/completionsFetchServiceImpl';
-import { APIUsage } from '../../networking/common/openai';
-import { ThinkingData } from '../../thinking/common/thinking';
-
-export type UriData = { kind: 'request'; id: string } | { kind: 'latest' };
-
-export class ChatRequestScheme {
-	public static readonly chatRequestScheme = 'ccreq';
-
-	public static buildUri(data: UriData, format: 'markdown' | 'json' = 'markdown'): string {
-		const extension = format === 'json' ? 'json' : 'copilotmd';
-		if (data.kind === 'latest') {
-			return `${ChatRequestScheme.chatRequestScheme}:latest.${extension}`;
-		} else {
-			return `${ChatRequestScheme.chatRequestScheme}:${data.id}.${extension}`;
-		}
-	}
-
-	public static parseUri(uri: string): { data: UriData; format: 'markdown' | 'json' } | undefined {
-		// Check for latest markdown
-		if (uri === this.buildUri({ kind: 'latest' }, 'markdown')) {
-			return { data: { kind: 'latest' }, format: 'markdown' };
-		}
-		// Check for latest JSON
-		if (uri === this.buildUri({ kind: 'latest' }, 'json')) {
-			return { data: { kind: 'latest' }, format: 'json' };
-		}
-
-		// Check for specific request markdown
-		const mdMatch = uri.match(/ccreq:([^\s]+)\.copilotmd/);
-		if (mdMatch) {
-			return { data: { kind: 'request', id: mdMatch[1] }, format: 'markdown' };
-		}
-
-		// Check for specific request JSON
-		const jsonMatch = uri.match(/ccreq:([^\s]+)\.json/);
-		if (jsonMatch) {
-			return { data: { kind: 'request', id: jsonMatch[1] }, format: 'json' };
-		}
-
-		return undefined;
-	}
-
-	public static findAllUris(text: string): { uri: string; range: OffsetRange }[] {
-		const linkRE = /(ccreq:[^\s]+\.(copilotmd|json))/g;
-		return [...text.matchAll(linkRE)].map(
-			(m) => {
-				const identifier = m[1];
-				return {
-					uri: identifier,
-					range: new OffsetRange(m.index!, m.index! + identifier.length)
-				};
-			}
-		);
-	}
-}
-
-export const enum LoggedInfoKind {
-	Element,
-	Request,
-	ToolCall,
-}
-
-export interface ILoggedElementInfo {
-	kind: LoggedInfoKind.Element;
-	id: string;
-	name: string;
-	tokens: number;
-	maxTokens: number;
-	trace: HTMLTracer;
-	chatRequest: ChatRequest | undefined;
-	toJSON(): object;
-}
-
-export interface ILoggedRequestInfo {
-	kind: LoggedInfoKind.Request;
-	id: string;
-	entry: LoggedRequest;
-	chatRequest: ChatRequest | undefined;
-	toJSON(): object;
-}
-
-export interface ILoggedToolCall {
-	kind: LoggedInfoKind.ToolCall;
-	id: string;
-	name: string;
-	args: unknown;
-	response: LanguageModelToolResult2;
-	chatRequest: ChatRequest | undefined;
-	time: number;
-	thinking?: ThinkingData;
-	toJSON(): Promise<object>;
-}
-
-export interface ILoggedPendingRequest {
-	messages: Raw.ChatMessage[];
-	tools: (OpenAiFunctionTool | OpenAiResponsesFunctionTool)[] | undefined;
-	ourRequestId: string;
-	model: string;
-	location: ChatLocation;
-	intent?: string;
-	postOptions?: OptionalChatRequestParams;
-	body?: IEndpointBody;
-	ignoreStatefulMarker?: boolean;
-}
-
-export type LoggedInfo = ILoggedElementInfo | ILoggedRequestInfo | ILoggedToolCall;
-
-export const IRequestLogger = createServiceIdentifier<IRequestLogger>('IRequestLogger');
-export interface IRequestLogger {
-
-	readonly _serviceBrand: undefined;
-
-	promptRendererTracing: boolean;
-
-	captureInvocation<T>(request: ChatRequest, fn: () => Promise<T>): Promise<T>;
-
-	logToolCall(id: string, name: string, args: unknown, response: LanguageModelToolResult2, thinking?: ThinkingData): void;
-
-	logModelListCall(requestId: string, requestMetadata: RequestMetadata, models: IModelAPIResponse[]): void;
-
-	logChatRequest(debugName: string, chatEndpoint: IChatEndpointLogInfo, chatParams: ILoggedPendingRequest): PendingLoggedChatRequest;
-
-	logCompletionRequest(debugName: string, chatEndpoint: IChatEndpointLogInfo, chatParams: ICompletionFetchRequestLogParams, requestId: string): PendingLoggedCompletionRequest;
-
-	addPromptTrace(elementName: string, endpoint: IChatEndpointInfo, result: RenderPromptResult, trace: HTMLTracer): void;
-	addEntry(entry: LoggedRequest): void;
-
-	onDidChangeRequests: Event<void>;
-	getRequests(): LoggedInfo[];
-
-	enableWorkspaceEditTracing(): void;
-	disableWorkspaceEditTracing(): void;
-}
-
-export const enum LoggedRequestKind {
-	ChatMLSuccess = 'ChatMLSuccess',
-	ChatMLFailure = 'ChatMLFailure',
-	ChatMLCancelation = 'ChatMLCancelation',
-	CompletionSuccess = 'CompletionSuccess',
-	CompletionFailure = 'CompletionFailure',
-	MarkdownContentRequest = 'MarkdownContentRequest',
-}
-
-export type IChatEndpointLogInfo = Partial<Pick<IChatEndpoint, 'model' | 'modelMaxPromptTokens' | 'urlOrRequestMetadata'>>;
-
-export interface ICompletionFetchRequestLogParams extends IFetchRequestParams {
-	ourRequestId: string;
-	postOptions?: ModelParams;
-	location: ChatLocation;
-	intent?: false;
-}
-
-export interface ILoggedChatMLRequest {
-	debugName: string;
-	chatEndpoint: IChatEndpointLogInfo;
-	chatParams: ILoggedPendingRequest | ICompletionFetchRequestLogParams;
-	startTime: Date;
-	endTime: Date;
-}
-
-export interface ILoggedChatMLSuccessRequest extends ILoggedChatMLRequest {
-	type: LoggedRequestKind.ChatMLSuccess;
-	timeToFirstToken: number | undefined;
-	usage: APIUsage | undefined;
-	result: FetchSuccess<string[]>;
-	deltas?: IResponseDelta[];
-}
-
-export interface ILoggedChatMLFailureRequest extends ILoggedChatMLRequest {
-	type: LoggedRequestKind.ChatMLFailure;
-	timeToFirstToken: number | undefined;
-	result: ChatFetchError;
-}
-
-export interface ILoggedChatMLCancelationRequest extends ILoggedChatMLRequest {
-	type: LoggedRequestKind.ChatMLCancelation;
-}
-
-export interface IMarkdownContentRequest {
-	type: LoggedRequestKind.MarkdownContentRequest;
-	startTimeMs: number;
-	icon: ThemeIcon | undefined;
-	debugName: string;
-	markdownContent: string;
-}
-
-export interface ILoggedCompletionSuccessRequest extends ILoggedChatMLRequest {
-	type: LoggedRequestKind.CompletionSuccess;
-	timeToFirstToken: number | undefined;
-	result: { type: ChatFetchResponseType.Success; value: string; requestId: string };
-	deltas?: undefined;
-}
-
-export interface ILoggedCompletionFailureRequest extends ILoggedChatMLRequest {
-	type: LoggedRequestKind.CompletionFailure;
-	timeToFirstToken: number | undefined;
-	result: { type: CompletionsFetchFailure | Error; requestId: string };
-}
-
-export type LoggedRequest = (
-	ILoggedChatMLSuccessRequest
-	| ILoggedChatMLFailureRequest
-	| ILoggedChatMLCancelationRequest
-	| IMarkdownContentRequest
-	| ILoggedCompletionSuccessRequest
-	| ILoggedCompletionFailureRequest
-);
-
-const requestLogStorage = new AsyncLocalStorage<ChatRequest>();
-
-export abstract class AbstractRequestLogger extends Disposable implements IRequestLogger {
-	declare _serviceBrand: undefined;
-
-	public get promptRendererTracing() {
-		return false;
-	}
-
-	public captureInvocation<T>(request: ChatRequest, fn: () => Promise<T>): Promise<T> {
-		return requestLogStorage.run(request, () => fn());
-	}
-
-	public abstract logModelListCall(id: string, requestMetadata: RequestMetadata, models: IModelAPIResponse[]): void;
-	public abstract logToolCall(id: string, name: string | undefined, args: unknown, response: LanguageModelToolResult2): void;
-
-	public logChatRequest(debugName: string, chatEndpoint: IChatEndpoint, chatParams: ILoggedPendingRequest): PendingLoggedChatRequest {
-		return new PendingLoggedChatRequest(this, debugName, chatEndpoint, chatParams);
-	}
-
-	public logCompletionRequest(debugName: string, chatEndpoint: IChatEndpointLogInfo, chatParams: ICompletionFetchRequestLogParams, requestId: string): PendingLoggedCompletionRequest {
-		return new PendingLoggedCompletionRequest(this, debugName, chatEndpoint, chatParams, requestId);
-	}
-
-	public abstract addPromptTrace(elementName: string, endpoint: IChatEndpointInfo, result: RenderPromptResult, trace: HTMLTracer): void;
-	public abstract addEntry(entry: LoggedRequest): void;
-	public abstract getRequests(): LoggedInfo[];
-	abstract onDidChangeRequests: Event<void>;
-
-	public enableWorkspaceEditTracing(): void {
-		// no-op by default; concrete implementations can override
-	}
-
-	public disableWorkspaceEditTracing(): void {
-		// no-op by default; concrete implementations can override
-	}
-
-	/** Current request being made to the LM. */
-	protected get currentRequest() {
-		return requestLogStorage.getStore();
-	}
-}
-
-class AbstractPendingLoggedRequest {
-	protected _time: Date;
-	protected _timeToFirstToken: number | undefined = undefined;
-
-	constructor(
-		protected _logbook: IRequestLogger,
-		protected _debugName: string,
-		protected _chatEndpoint: IChatEndpointLogInfo,
-		protected _chatParams: ILoggedPendingRequest | ICompletionFetchRequestLogParams
-	) {
-		this._time = new Date();
-	}
-
-	markTimeToFirstToken(timeToFirstToken: number): void {
-		this._timeToFirstToken = timeToFirstToken;
-	}
-
-	resolveWithCancelation() {
-		this._logbook.addEntry({
-			type: LoggedRequestKind.ChatMLCancelation,
-			debugName: this._debugName,
-			chatEndpoint: this._chatEndpoint,
-			chatParams: this._chatParams,
-			startTime: this._time,
-			endTime: new Date()
-		});
-	}
-}
-
-export class PendingLoggedCompletionRequest extends AbstractPendingLoggedRequest {
-
-	constructor(
-		logbook: IRequestLogger,
-		debugName: string,
-		chatEndpoint: IChatEndpointLogInfo,
-		chatParams: ICompletionFetchRequestLogParams,
-		private requestId: string
-	) {
-		super(logbook, debugName, chatEndpoint, chatParams);
-	}
-
-	resolve(result: Result<Completion, CompletionsFetchFailure | Error>): void {
-		if (result.isOk()) {
-			const completionText = result.val.choices.at(0)?.text;
-			assertType(completionText !== undefined, 'Completion with empty choices');
-
-			this._logbook.addEntry({
-				type: LoggedRequestKind.CompletionSuccess,
-				debugName: this._debugName,
-				chatEndpoint: this._chatEndpoint,
-				chatParams: this._chatParams,
-				startTime: this._time,
-				endTime: new Date(),
-				timeToFirstToken: this._timeToFirstToken,
-				result: { type: ChatFetchResponseType.Success, value: completionText, requestId: this.requestId },
-			});
-		} else {
-			this._logbook.addEntry({
-				type: LoggedRequestKind.CompletionFailure,
-				debugName: this._debugName,
-				chatEndpoint: this._chatEndpoint,
-				chatParams: this._chatParams,
-				startTime: this._time,
-				endTime: new Date(),
-				timeToFirstToken: this._timeToFirstToken,
-				result: { type: result.err, requestId: this.requestId },
-			});
-		}
-	}
-}
-
-export class PendingLoggedChatRequest extends AbstractPendingLoggedRequest {
-	constructor(
-		logbook: IRequestLogger,
-		debugName: string,
-		chatEndpoint: IChatEndpoint,
-		chatParams: ILoggedPendingRequest
-	) {
-		super(logbook, debugName, chatEndpoint, chatParams);
-	}
-
-	resolve(result: ChatResponses, deltas?: IResponseDelta[]): void {
-		if (result.type === ChatFetchResponseType.Success) {
-			this._logbook.addEntry({
-				type: LoggedRequestKind.ChatMLSuccess,
-				debugName: this._debugName,
-				usage: result.usage,
-				chatEndpoint: this._chatEndpoint,
-				chatParams: this._chatParams,
-				startTime: this._time,
-				endTime: new Date(),
-				timeToFirstToken: this._timeToFirstToken,
-				result,
-				deltas
-			});
-		} else {
-			this._logbook.addEntry({
-				type: result.type === ChatFetchResponseType.Canceled ? LoggedRequestKind.ChatMLCancelation : LoggedRequestKind.ChatMLFailure,
-				debugName: this._debugName,
-				chatEndpoint: this._chatEndpoint,
-				chatParams: this._chatParams,
-				startTime: this._time,
-				endTime: new Date(),
-				timeToFirstToken: this._timeToFirstToken,
-				result,
-			});
-		}
-	}
-}

package/src/_internal/platform/simulationTestContext/common/simulationTestContext.ts

@@ -1,29 +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 { createServiceIdentifier } from '../../../util/common/services';
-
-export const ISimulationTestContext = createServiceIdentifier<ISimulationTestContext>('ISimulationTestContext');
-
-export interface ISimulationTestContext {
-
-	_serviceBrand: undefined;
-
-	readonly isInSimulationTests: boolean;
-
-	writeFile(filename: string, contents: Uint8Array | string, tag: string): Promise<string>;
-}
-
-
-export class NulSimulationTestContext implements ISimulationTestContext {
-
-	_serviceBrand: undefined;
-
-	readonly isInSimulationTests = false;
-
-	async writeFile(filename: string, contents: Uint8Array | string, tag: string): Promise<string> {
-		return '';
-	}
-}

package/src/_internal/platform/snippy/common/snippyService.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 { createServiceIdentifier } from '../../../util/common/services';
-import { URI } from '../../../util/vs/base/common/uri';
-import { StringReplacement } from '../../../util/vs/editor/common/core/edits/stringEdit';
-import { StringText } from '../../../util/vs/editor/common/core/text/abstractText';
-
-export interface ISnippyService {
-	_serviceBrand: undefined;
-
-	handlePostInsertion(documentUri: URI, documentBeforeEdits: StringText, singleEdit: StringReplacement): Promise<void>;
-}
-
-export const ISnippyService = createServiceIdentifier<ISnippyService>('ISnippyService');
-
-export class NullSnippyService implements ISnippyService {
-	_serviceBrand: undefined;
-
-	public async handlePostInsertion(): Promise<void> {
-		return;
-	}
-}