@vscode/chat-lib 0.0.1 → 0.0.2

package/src/_internal/platform/authentication/common/copilotTokenManager.ts

@@ -1,59 +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 { Event } from '../../../util/vs/base/common/event';
-import { CopilotToken, TokenError, TokenErrorReason } from './copilotToken';
-
-export const ICopilotTokenManager = createServiceIdentifier<ICopilotTokenManager>('ICopilotTokenManager');
-
-/**
- * @deprecated Use `IAuthenticationService` instead
- */
-export interface ICopilotTokenManager {
-
-	readonly _serviceBrand: undefined;
-
-	/**
-	 * Event emitter that will fire an event every time a token refresh is requested.
-	 *
-	 * This is used for example in the repo enablement code (lib/src/enablement.ts),
-	 * where we need to clear the list of cached repos whenever we request a new token.
-	 */
-	readonly onDidCopilotTokenRefresh: Event<void>;
-
-	/**
-	 * Return a currently valid Copilot token, retrieving a fresh one if
-	 * necessary.
-	 *
-	 * Note that a Copilot token manager should not provide a Copilot token unless
-	 * telemetry consent has been obtained. If this is not checked by the token manager
-	 * implementation itself, then anything constructing or initialising it should not
-	 * do so without checking this. force will force a refresh of the token, even not expired
-	 */
-	getCopilotToken(force?: boolean): Promise<CopilotToken>;
-
-	/**
-	 * Drop the current Copilot token as we received an HTTP error while trying
-	 * to use it that indicates it's no longer valid.
-	 */
-	resetCopilotToken(httpError?: number): void;
-}
-
-export function nowSeconds(): number {
-	return Math.floor(Date.now() / 1000);
-}
-
-export type NotGitHubLoginFailed = { kind: 'success' } | { kind: 'failure'; reason: Exclude<TokenErrorReason, 'GitHubLoginFailed'> };
-
-//#region Testing Copilot Token Mangers
-
-/** Intended for use as an add-on to `CopilotTokenManager`,
- *  that checks that a valid Copilot token is available. For tests.
- */
-export interface CheckCopilotToken {
-	/** Check that the object has access to a valid Copilot token. */
-	checkCopilotToken(): Promise<{ status: 'OK' } | (TokenError & { reason: Exclude<TokenErrorReason, 'GitHubLoginFailed'> })>;
-}

package/src/_internal/platform/authentication/common/copilotTokenStore.ts

@@ -1,40 +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 { Emitter, Event } from '../../../util/vs/base/common/event';
-import { Disposable } from '../../../util/vs/base/common/lifecycle';
-import type { CopilotToken } from './copilotToken';
-
-
-export const ICopilotTokenStore = createServiceIdentifier<ICopilotTokenStore>('ICopilotTokenStore');
-
-/**
- * A simple store that holds the Copilot Token. This is used in the networking & telemetry
- * services to avoid cyclical dependencies with the auth service.
- * @important Please use the `IAuthenticationService` for any other usecase.
- */
-export interface ICopilotTokenStore {
-	readonly _serviceBrand: undefined;
-	copilotToken: CopilotToken | undefined;
-	onDidStoreUpdate: Event<void>;
-}
-
-export class CopilotTokenStore extends Disposable implements ICopilotTokenStore {
-	declare readonly _serviceBrand: undefined;
-	private _copilotToken: CopilotToken | undefined;
-	private readonly _onDidStoreUpdate = this._register(new Emitter<void>());
-	onDidStoreUpdate: Event<void> = this._onDidStoreUpdate.event;
-
-	get copilotToken(): CopilotToken | undefined {
-		return this._copilotToken;
-	}
-	set copilotToken(token: CopilotToken | undefined) {
-		const oldToken = this._copilotToken?.token;
-		this._copilotToken = token;
-		if (oldToken !== token?.token) {
-			this._onDidStoreUpdate.fire();
-		}
-	}
-}

package/src/_internal/platform/authentication/common/staticGitHubAuthenticationService.ts

@@ -1,96 +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 { AuthenticationGetSessionOptions, AuthenticationSession } from 'vscode';
-import { IConfigurationService } from '../../configuration/common/configurationService';
-import { ILogService } from '../../log/common/logService';
-import { BaseAuthenticationService, GITHUB_SCOPE_ALIGNED, GITHUB_SCOPE_USER_EMAIL, IAuthenticationService, MinimalModeError } from './authentication';
-import { CopilotToken } from './copilotToken';
-import { ICopilotTokenManager } from './copilotTokenManager';
-import { ICopilotTokenStore } from './copilotTokenStore';
-
-export class StaticGitHubAuthenticationService extends BaseAuthenticationService {
-
-	private _githubToken: string | undefined;
-	get githubToken(): string {
-		if (!this._githubToken) {
-			this._githubToken = this.tokenProvider();
-		}
-		return this._githubToken;
-	}
-
-	private readonly tokenProvider: { (): string };
-
-	constructor(
-		tokenProvider: { (): string },
-		@ILogService logService: ILogService,
-		@ICopilotTokenStore tokenStore: ICopilotTokenStore,
-		@ICopilotTokenManager tokenManager: ICopilotTokenManager,
-		@IConfigurationService configurationService: IConfigurationService
-	) {
-		super(logService, tokenStore, tokenManager, configurationService);
-		this.tokenProvider = tokenProvider;
-
-		const that = this;
-		this._anyGitHubSession = {
-			get id() { return that.githubToken; },
-			get accessToken() { return that.githubToken; },
-			scopes: GITHUB_SCOPE_USER_EMAIL,
-			account: {
-				id: 'user',
-				label: 'User'
-			}
-		};
-
-		this._permissiveGitHubSession = {
-			get id() { return that.githubToken; },
-			get accessToken() { return that.githubToken; },
-			scopes: GITHUB_SCOPE_ALIGNED,
-			account: {
-				id: 'user',
-				label: 'User'
-			}
-		};
-	}
-
-	getAnyGitHubSession(_options?: AuthenticationGetSessionOptions): Promise<AuthenticationSession | undefined> {
-		return Promise.resolve(this._anyGitHubSession);
-	}
-
-	getPermissiveGitHubSession(options: AuthenticationGetSessionOptions): Promise<AuthenticationSession | undefined> {
-		if (this.isMinimalMode) {
-			if (options.createIfNone || options.forceNewSession) {
-				throw new MinimalModeError();
-			}
-			return Promise.resolve(undefined);
-		}
-		return Promise.resolve(this._permissiveGitHubSession);
-	}
-
-	override async getCopilotToken(force?: boolean): Promise<CopilotToken> {
-		return await super.getCopilotToken(force);
-	}
-
-	setCopilotToken(token: CopilotToken): void {
-		this._tokenStore.copilotToken = token;
-		this._onDidAuthenticationChange.fire();
-	}
-
-
-	override getAnyAdoSession(_options?: AuthenticationGetSessionOptions): Promise<AuthenticationSession | undefined> {
-		return Promise.resolve(undefined);
-	}
-
-	override getAdoAccessTokenBase64(options?: AuthenticationGetSessionOptions): Promise<string | undefined> {
-		return Promise.resolve(undefined);
-	}
-}
-
-export function setCopilotToken(authenticationService: IAuthenticationService, token: CopilotToken): void {
-	if (!(authenticationService instanceof StaticGitHubAuthenticationService)) {
-		throw new Error('This function should only be used with StaticGitHubAuthenticationService');
-	}
-	(authenticationService as StaticGitHubAuthenticationService).setCopilotToken(token);
-}

package/src/_internal/platform/authentication/node/copilotTokenManager.ts

@@ -1,303 +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 { RequestType } from '@vscode/copilot-api';
-import { Emitter } from '../../../util/vs/base/common/event';
-import { Disposable, toDisposable } from '../../../util/vs/base/common/lifecycle';
-import { SyncDescriptor } from '../../../util/vs/platform/instantiation/common/descriptors';
-import { IConfigurationService } from '../../configuration/common/configurationService';
-import { ICAPIClientService } from '../../endpoint/common/capiClient';
-import { IDomainService } from '../../endpoint/common/domainService';
-import { IEnvService } from '../../env/common/envService';
-import { BaseOctoKitService, VSCodeTeamId } from '../../github/common/githubService';
-import { NullBaseOctoKitService } from '../../github/common/nullOctokitServiceImpl';
-import { ILogService } from '../../log/common/logService';
-import { FetchOptions, IFetcherService, Response, jsonVerboseError } from '../../networking/common/fetcherService';
-import { ITelemetryService } from '../../telemetry/common/telemetry';
-import { TelemetryData } from '../../telemetry/common/telemetryData';
-import { CopilotToken, CopilotUserInfo, ExtendedTokenInfo, TokenInfo, TokenInfoOrError, containsInternalOrg } from '../common/copilotToken';
-import { CheckCopilotToken, ICopilotTokenManager, NotGitHubLoginFailed, nowSeconds } from '../common/copilotTokenManager';
-
-export const tokenErrorString = `Tests: either GITHUB_PAT or GITHUB_OAUTH_TOKEN must be set. Run "npm run get_token" to get one.`;
-
-export function getStaticGitHubToken() {
-	if (process.env.GITHUB_PAT) {
-		return process.env.GITHUB_PAT;
-	}
-	if (process.env.GITHUB_OAUTH_TOKEN) {
-		return process.env.GITHUB_OAUTH_TOKEN;
-	}
-	throw new Error(tokenErrorString);
-}
-
-export function getOrCreateTestingCopilotTokenManager(): SyncDescriptor<ICopilotTokenManager & CheckCopilotToken> {
-	let result: SyncDescriptor<ICopilotTokenManager & CheckCopilotToken> | undefined;
-	if (process.env.GITHUB_PAT) {
-		result = new SyncDescriptor(FixedCopilotTokenManager, [process.env.GITHUB_PAT]);
-	}
-	if (process.env.GITHUB_OAUTH_TOKEN) {
-		result = new SyncDescriptor(CopilotTokenManagerFromGitHubToken, [process.env.GITHUB_OAUTH_TOKEN]);
-	}
-	if (!result) {
-		throw new Error(tokenErrorString);
-	}
-	return result;
-}
-
-//TODO: Move this to common
-export abstract class BaseCopilotTokenManager extends Disposable implements ICopilotTokenManager {
-	declare readonly _serviceBrand: undefined;
-
-	protected _isDisposed = false;
-
-	//#region Events
-	private readonly _copilotTokenRefreshEmitter = this._register(new Emitter<void>());
-	readonly onDidCopilotTokenRefresh = this._copilotTokenRefreshEmitter.event;
-
-	//#endregion
-	constructor(
-		protected readonly _baseOctokitservice: BaseOctoKitService,
-		protected readonly _logService: ILogService,
-		protected readonly _telemetryService: ITelemetryService,
-		protected readonly _domainService: IDomainService,
-		protected readonly _capiClientService: ICAPIClientService,
-		protected readonly _fetcherService: IFetcherService,
-		protected readonly _envService: IEnvService
-	) {
-		super();
-		this._register(toDisposable(() => this._isDisposed = true));
-	}
-
-	//#region Property getters and setters
-	private _copilotToken: ExtendedTokenInfo | undefined;
-	get copilotToken(): ExtendedTokenInfo | undefined {
-		return this._copilotToken;
-	}
-	set copilotToken(token: ExtendedTokenInfo | undefined) {
-		if (token !== this._copilotToken) {
-			this._copilotToken = token;
-			this._copilotTokenRefreshEmitter.fire();
-		}
-	}
-
-	//#endregion
-	//#region Abstract methods
-	abstract getCopilotToken(force?: boolean): Promise<CopilotToken>;
-
-	//#endregion
-	//#region Public methods
-	resetCopilotToken(httpError?: number): void {
-		if (httpError !== undefined) {
-			this._telemetryService.sendGHTelemetryEvent('auth.reset_token_' + httpError);
-		}
-		this._logService.debug(`Resetting copilot token on HTTP error ${httpError || 'unknown'}`);
-		this.copilotToken = undefined;
-	}
-
-	/**
-	 * Fetches a Copilot token from the GitHub token.
-	 * @param githubToken A GitHub token to mint a Copilot token from.
-	 * @returns A Copilot token info or an error.
-	 * @todo this should be not be public, but it is for now to allow testing.
-	 */
-	async authFromGitHubToken(
-		githubToken: string,
-		ghUsername: string
-	): Promise<TokenInfoOrError & NotGitHubLoginFailed> {
-		this._telemetryService.sendGHTelemetryEvent('auth.new_login');
-		const [response, userInfo] = await Promise.all([
-			this.fetchCopilotToken(githubToken),
-			this.fetchCopilotUserInfo(githubToken)
-		]);
-		if (!response) {
-			this._logService.warn('Failed to get copilot token');
-			this._telemetryService.sendGHTelemetryErrorEvent('auth.request_failed');
-			return { kind: 'failure', reason: 'FailedToGetToken' };
-		}
-
-		// FIXME: Unverified type after inputting response
-		const tokenInfo: undefined | TokenInfo = await jsonVerboseError(response);
-		if (!tokenInfo) {
-			this._logService.warn('Failed to get copilot token');
-			this._telemetryService.sendGHTelemetryErrorEvent('auth.request_read_failed');
-			return { kind: 'failure', reason: 'FailedToGetToken' };
-		}
-
-		if (response.status === 401) {
-			this._logService.warn('Failed to get copilot token due to 401 status');
-			this._telemetryService.sendGHTelemetryErrorEvent('auth.unknown_401');
-			return { kind: 'failure', reason: 'HTTP401' };
-		}
-
-		if (response.status === 403 && tokenInfo.message?.startsWith('API rate limit exceeded')) {
-			this._logService.warn('Failed to get copilot token due to exceeding API rate limit');
-			this._telemetryService.sendGHTelemetryErrorEvent('auth.rate_limited');
-			return { kind: 'failure', reason: 'RateLimited' };
-		}
-
-		if (!response.ok || !tokenInfo.token) {
-			this._logService.warn(`Invalid copilot token: missing token: ${response.status} ${response.statusText}`);
-			const data = TelemetryData.createAndMarkAsIssued({
-				status: response.status.toString(),
-				status_text: response.statusText,
-			});
-			this._telemetryService.sendGHTelemetryErrorEvent('auth.invalid_token', data.properties, data.measurements);
-			const error_details = tokenInfo.error_details;
-			return { kind: 'failure', reason: 'NotAuthorized', ...error_details };
-		}
-
-		const expires_at = tokenInfo.expires_at;
-		// some users have clocks adjusted ahead, expires_at will immediately be less than current clock time;
-		// adjust expires_at to the refresh time + a buffer to avoid expiring the token before the refresh can fire.
-		tokenInfo.expires_at = nowSeconds() + tokenInfo.refresh_in + 60; // extra buffer to allow refresh to happen successfully
-
-		// extend the token envelope
-		const login = ghUsername ?? 'unknown';
-		let isVscodeTeamMember = false;
-		// VS Code team members are guaranteed to be a part of an internal org so we can check that first to minimize API calls
-		if (containsInternalOrg(tokenInfo.organization_list ?? [])) {
-			isVscodeTeamMember = !!(await this._baseOctokitservice.getTeamMembershipWithToken(VSCodeTeamId, githubToken, login));
-		}
-		const extendedInfo: ExtendedTokenInfo = {
-			...tokenInfo,
-			copilot_plan: userInfo.copilot_plan,
-			quota_snapshots: userInfo.quota_snapshots,
-			quota_reset_date: userInfo.quota_reset_date,
-			username: login,
-			isVscodeTeamMember,
-		};
-		const telemetryData = TelemetryData.createAndMarkAsIssued(
-			{},
-			{
-				adjusted_expires_at: tokenInfo.expires_at,
-				expires_at: expires_at, // track original expires_at
-				current_time: nowSeconds(),
-			}
-		);
-
-		this._telemetryService.sendGHTelemetryEvent('auth.new_token', telemetryData.properties, telemetryData.measurements);
-
-		return { kind: 'success', ...extendedInfo };
-	}
-
-	//#endregion
-
-	//#region Private methods
-	private async fetchCopilotToken(githubToken: string) {
-		const options: FetchOptions = {
-			headers: {
-				Authorization: `token ${githubToken}`,
-				'X-GitHub-Api-Version': '2025-04-01'
-			},
-			verifyJSONAndRetry: true,
-		};
-		return await this._capiClientService.makeRequest<Response>(options, { type: RequestType.CopilotToken });
-	}
-
-	private async fetchCopilotUserInfo(githubToken: string): Promise<CopilotUserInfo> {
-		const response = await this._capiClientService.makeRequest<Response>({
-			headers: {
-				Authorization: `token ${githubToken}`,
-				'X-GitHub-Api-Version': '2025-04-01',
-			}
-		}, { type: RequestType.CopilotUserInfo });
-		const data = await response.json();
-		return data;
-	}
-}
-
-//#region FixedCopilotTokenManager
-
-/**
- * A `CopilotTokenManager` that always returns the same token.
- * Mostly only useful for short periods, e.g. tests or single completion requests,
- * as these tokens typically expire after a few hours.
- * @todo Move this to a test layer
- */
-
-export class FixedCopilotTokenManager extends BaseCopilotTokenManager implements CheckCopilotToken {
-	constructor(
-		private _completionsToken: string,
-		@ILogService logService: ILogService,
-		@ITelemetryService telemetryService: ITelemetryService,
-		@ICAPIClientService capiClientService: ICAPIClientService,
-		@IDomainService domainService: IDomainService,
-		@IFetcherService fetcherService: IFetcherService,
-		@IEnvService envService: IEnvService
-	) {
-		super(new NullBaseOctoKitService(capiClientService, fetcherService, logService, telemetryService), logService, telemetryService, domainService, capiClientService, fetcherService, envService);
-		this.copilotToken = { token: _completionsToken, expires_at: 0, refresh_in: 0, username: 'fixedTokenManager', isVscodeTeamMember: false, copilot_plan: 'unknown' };
-	}
-
-	set completionsToken(token: string) {
-		this._completionsToken = token;
-		this.copilotToken = { token, expires_at: 0, refresh_in: 0, username: 'fixedTokenManager', isVscodeTeamMember: false, copilot_plan: 'unknown' };
-	}
-	get completionsToken(): string {
-		return this._completionsToken;
-	}
-
-	async getCopilotToken(): Promise<CopilotToken> {
-		return new CopilotToken(this.copilotToken!);
-	}
-
-	async checkCopilotToken(): Promise<{ status: 'OK' }> {
-		// assume it's valid
-		return { status: 'OK' };
-	}
-}
-
-//#endregion
-
-//#region CopilotTokenManagerFromGitHubToken
-
-/**
- * Given a GitHub token, return a Copilot token, refreshing it as needed.
- * The caller that initializes the object is responsible for checking telemetry consent before
- * using the object.
- */
-export class CopilotTokenManagerFromGitHubToken extends BaseCopilotTokenManager implements CheckCopilotToken {
-
-	constructor(
-		private readonly githubToken: string,
-		private readonly githubUsername: string,
-		@ILogService logService: ILogService,
-		@ITelemetryService telemetryService: ITelemetryService,
-		@IDomainService domainService: IDomainService,
-		@ICAPIClientService capiClientService: ICAPIClientService,
-		@IFetcherService fetcherService: IFetcherService,
-		@IEnvService envService: IEnvService,
-		@IConfigurationService protected readonly configurationService: IConfigurationService
-	) {
-		super(new NullBaseOctoKitService(capiClientService, fetcherService, logService, telemetryService), logService, telemetryService, domainService, capiClientService, fetcherService, envService);
-	}
-
-	async getCopilotToken(force?: boolean): Promise<CopilotToken> {
-		if (!this.copilotToken || this.copilotToken.expires_at < nowSeconds() - (60 * 5 /* 5min */) || force) {
-			const tokenResult = await this.authFromGitHubToken(this.githubToken, this.githubUsername);
-			if (tokenResult.kind === 'failure') {
-				throw Error(
-					`Failed to get copilot token: ${tokenResult.reason.toString()} ${tokenResult.message ?? ''}`
-				);
-			}
-			this.copilotToken = { ...tokenResult };
-		}
-		return new CopilotToken(this.copilotToken);
-	}
-
-	async checkCopilotToken() {
-		if (!this.copilotToken || this.copilotToken.expires_at < nowSeconds()) {
-			const tokenResult = await this.authFromGitHubToken(this.githubToken, this.githubUsername);
-			if (tokenResult.kind === 'failure') {
-				return tokenResult;
-			}
-			this.copilotToken = { ...tokenResult };
-		}
-		const result: { status: 'OK' } = {
-			status: 'OK',
-		};
-		return result;
-	}
-}

package/src/_internal/platform/chat/common/chatMLFetcher.ts

@@ -1,124 +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 } from 'vscode';
-import { createServiceIdentifier } from '../../../util/common/services';
-import { AsyncIterableObject, AsyncIterableSource } from '../../../util/vs/base/common/async';
-import { Event } from '../../../util/vs/base/common/event';
-import { FinishedCallback, IResponseDelta, OptionalChatRequestParams } from '../../networking/common/fetch';
-import { IChatEndpoint, IMakeChatRequestOptions } from '../../networking/common/networking';
-import { ChatResponse, ChatResponses } from './commonTypes';
-
-export interface Source {
-	readonly extensionId?: string;
-}
-
-export interface IResponsePart {
-	readonly text: string;
-	readonly delta: IResponseDelta;
-}
-
-export interface IFetchMLOptions extends IMakeChatRequestOptions {
-	endpoint: IChatEndpoint;
-	requestOptions: OptionalChatRequestParams;
-}
-
-
-export const IChatMLFetcher = createServiceIdentifier<IChatMLFetcher>('IChatMLFetcher');
-
-export interface IChatMLFetcher {
-
-	readonly _serviceBrand: undefined;
-
-	readonly onDidMakeChatMLRequest: Event<{ readonly model: string; readonly source?: Source; readonly tokenCount?: number }>;
-
-	fetchOne(options: IFetchMLOptions, token: CancellationToken): Promise<ChatResponse>;
-
-	/**
-	 * Note: the returned array of strings may be less than `n` (e.g., in case there were errors during streaming)
-	 */
-	fetchMany(options: IFetchMLOptions, token: CancellationToken): Promise<ChatResponses>;
-}
-
-export class FetchStreamSource {
-
-	private _stream = new AsyncIterableSource<IResponsePart>();
-	private _paused?: (IResponsePart | undefined)[];
-
-	// This means that we will only show one instance of each annotation type, but the IDs are not correct and there is no other way
-	private _seenAnnotationTypes = new Set<string>();
-
-	public get stream(): AsyncIterableObject<IResponsePart> {
-		return this._stream.asyncIterable;
-	}
-
-	constructor() { }
-
-	pause() {
-		this._paused ??= [];
-	}
-
-	unpause() {
-		const toEmit = this._paused;
-		if (!toEmit) {
-			return;
-		}
-
-		this._paused = undefined;
-		for (const part of toEmit) {
-			if (part) {
-				this.update(part.text, part.delta);
-			} else {
-				this.resolve();
-			}
-		}
-	}
-
-	update(text: string, delta: IResponseDelta): void {
-		if (this._paused) {
-			this._paused.push({ text, delta });
-			return;
-		}
-
-		if (delta.codeVulnAnnotations) {
-			// We can only display vulnerabilities inside codeblocks, and it's ok to discard annotations that fell outside of them
-			const numTripleBackticks = text.match(/(^|\n)```/g)?.length ?? 0;
-			const insideCodeblock = numTripleBackticks % 2 === 1;
-			if (!insideCodeblock || text.match(/(^|\n)```\w*\s*$/)) { // Not inside a codeblock, or right on the start triple-backtick of a codeblock
-				delta.codeVulnAnnotations = undefined;
-			}
-		}
-
-		if (delta.codeVulnAnnotations) {
-			delta.codeVulnAnnotations = delta.codeVulnAnnotations.filter(annotation => !this._seenAnnotationTypes.has(annotation.details.type));
-			delta.codeVulnAnnotations.forEach(annotation => this._seenAnnotationTypes.add(annotation.details.type));
-		}
-		this._stream.emitOne({ text, delta });
-	}
-
-	resolve(): void {
-		if (this._paused) {
-			this._paused.push(undefined);
-			return;
-		}
-
-		this._stream.resolve();
-	}
-}
-
-export class FetchStreamRecorder {
-	public readonly callback: FinishedCallback;
-	public readonly deltas: IResponseDelta[] = [];
-
-	constructor(
-		callback: FinishedCallback | undefined
-	) {
-		this.callback = async (text: string, index: number, delta: IResponseDelta): Promise<number | undefined> => {
-			const result = callback ? await callback(text, index, delta) : undefined;
-			this.deltas.push(delta);
-			return result;
-		};
-	}
-}

package/src/_internal/platform/chat/common/chatQuotaService.ts

@@ -1,63 +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 { IHeaders } from '../../networking/common/fetcherService';
-
-/**
- * This is the quota info we get from the `copilot_internal/user` endpoint.
- * It is accessed via the copilot token object
- */
-export interface CopilotUserQuotaInfo {
-	quota_reset_date?: string;
-	quota_snapshots?: {
-		chat: {
-			quota_id: string;
-			entitlement: number;
-			remaining: number;
-			unlimited: boolean;
-			overage_count: number;
-			overage_permitted: boolean;
-			percent_remaining: number;
-		};
-		completions: {
-			quota_id: string;
-			entitlement: number;
-			remaining: number;
-			unlimited: boolean;
-			overage_count: number;
-			overage_permitted: boolean;
-			percent_remaining: number;
-		};
-		premium_interactions: {
-			quota_id: string;
-			entitlement: number;
-			remaining: number;
-			unlimited: boolean;
-			overage_count: number;
-			overage_permitted: boolean;
-			percent_remaining: number;
-		};
-	};
-}
-
-export interface IChatQuota {
-	quota: number;
-	used: number;
-	unlimited: boolean;
-	overageUsed: number;
-	overageEnabled: boolean;
-	resetDate: Date;
-}
-
-export interface IChatQuotaService {
-	readonly _serviceBrand: undefined;
-	quotaExhausted: boolean;
-	overagesEnabled: boolean;
-	processQuotaHeaders(headers: IHeaders): void;
-	clearQuota(): void;
-}
-
-export const IChatQuotaService = createServiceIdentifier<IChatQuotaService>('IChatQuotaService');