@vscode/chat-lib 0.0.1

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

@@ -0,0 +1,190 @@
+/*---------------------------------------------------------------------------------------------
+ *  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

@@ -0,0 +1,26 @@
+/*---------------------------------------------------------------------------------------------
+ *  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

@@ -0,0 +1,383 @@
+/*---------------------------------------------------------------------------------------------
+ *  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

@@ -0,0 +1,29 @@
+/*---------------------------------------------------------------------------------------------
+ *  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

@@ -0,0 +1,25 @@
+/*---------------------------------------------------------------------------------------------
+ *  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;
+	}
+}