@vscode/chat-lib 0.0.1

package/src/_internal/platform/telemetry/common/nullExperimentationService.ts

@@ -0,0 +1,64 @@
+/*---------------------------------------------------------------------------------------------
+ *  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';
+
+
+/**
+ * An event describing the change in treatments.
+ */
+export interface TreatmentsChangeEvent {
+
+	/**
+	 * List of changed treatments
+	 */
+	affectedTreatmentVariables: string[];
+}
+
+/**
+ * Experimentation service provides A/B experimentation functionality.
+ * Currently it's per design to be able to only allow querying one flight at the time.
+ * This is in order for us to control events and telemetry whenever these methods are called.
+ */
+export interface IExperimentationService {
+	readonly _serviceBrand: undefined;
+
+	/**
+	 * Emitted whenever a treatment values have changes based on user account information or refresh.
+	 */
+	onDidTreatmentsChange: Event<TreatmentsChangeEvent>;
+
+
+	/**
+	 * Promise that resolves when the experimentation service has completed
+	 * its first request to the Treatment Assignment Service. If this request
+	 * is successful, flights are up-to-date. Flights can change when the user
+	 * changes their account.
+	 */
+	hasTreatments(): Promise<void>;
+
+	/**
+	 * Returns the value of the treatment variable, or undefined if not found.
+	 * It uses the values currently in memory, so the experimentation service
+	 * must be initialized before calling.
+	 * @param name name of the treatment variable.
+	 */
+	getTreatmentVariable<T extends boolean | number | string>(name: string): T | undefined;
+}
+
+export const IExperimentationService = createServiceIdentifier<IExperimentationService>('IExperimentationService');
+
+
+export class NullExperimentationService implements IExperimentationService {
+	declare readonly _serviceBrand: undefined;
+	private readonly _onDidTreatmentsChange = new Emitter<TreatmentsChangeEvent>();
+	readonly onDidTreatmentsChange = this._onDidTreatmentsChange.event;
+
+	async hasTreatments(): Promise<void> { return Promise.resolve(); }
+	async hasAccountBasedTreatments(): Promise<void> { return Promise.resolve(); }
+	getTreatmentVariable<T extends boolean | number | string>(_name: string): T | undefined {
+		return undefined;
+	}
+}

package/src/_internal/platform/telemetry/common/nullTelemetryService.ts

@@ -0,0 +1,53 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ITelemetryService, TelemetryDestination, TelemetryEventMeasurements, TelemetryEventProperties } from './telemetry';
+
+export class NullTelemetryService implements ITelemetryService {
+	declare readonly _serviceBrand: undefined;
+
+	dispose(): void {
+		return;
+	}
+
+	sendInternalMSFTTelemetryEvent(eventName: string, properties?: TelemetryEventProperties | undefined, measurements?: TelemetryEventMeasurements | undefined): void {
+		return;
+	}
+	sendMSFTTelemetryEvent(eventName: string, properties?: TelemetryEventProperties | undefined, measurements?: TelemetryEventMeasurements | undefined): void {
+		return;
+	}
+	sendMSFTTelemetryErrorEvent(eventName: string, properties?: TelemetryEventProperties | undefined, measurements?: TelemetryEventMeasurements | undefined): void {
+		return;
+	}
+	sendGHTelemetryEvent(eventName: string, properties?: TelemetryEventProperties | undefined, measurements?: TelemetryEventMeasurements | undefined): void {
+		return;
+	}
+	sendGHTelemetryErrorEvent(eventName: string, properties?: TelemetryEventProperties | undefined, measurements?: TelemetryEventMeasurements | undefined): void {
+		return;
+	}
+	sendGHTelemetryException(maybeError: unknown, origin: string): void {
+		return;
+	}
+	sendTelemetryEvent(eventName: string, destination: TelemetryDestination, properties?: TelemetryEventProperties | undefined, measurements?: TelemetryEventMeasurements | undefined): void {
+		return;
+	}
+	sendTelemetryErrorEvent(eventName: string, destination: TelemetryDestination, properties?: TelemetryEventProperties | undefined, measurements?: TelemetryEventMeasurements | undefined): void {
+		return;
+	}
+	setSharedProperty(name: string, value: string): void {
+		return;
+	}
+	postEvent(eventName: string, props: Map<string, string>): void {
+		return;
+	}
+
+	sendEnhancedGHTelemetryEvent(eventName: string, properties?: TelemetryEventProperties | undefined, measurements?: TelemetryEventMeasurements | undefined): void {
+		return;
+	}
+	sendEnhancedGHTelemetryErrorEvent(eventName: string, properties?: TelemetryEventProperties | undefined, measurements?: TelemetryEventMeasurements | undefined): void {
+		return;
+	}
+
+}

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

@@ -0,0 +1,215 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import type { TelemetrySender } from 'vscode';
+import { createServiceIdentifier } from '../../../util/common/services';
+import { IDisposable } from '../../../util/vs/base/common/lifecycle';
+import { ICopilotTokenStore } from '../../authentication/common/copilotTokenStore';
+import type { TelemetryData } from './telemetryData';
+
+
+// Interfaces taken from and should match `@vscode/extension-telemetry` package
+export interface TelemetryEventMeasurements {
+	readonly [key: string]: number | undefined;
+}
+
+export interface TelemetryEventProperties {
+	readonly [key: string]: string | import("vscode").TelemetryTrustedValue<string> | undefined;
+}
+
+// Interfaces taken from and should match `vscode-tas-client`
+/**
+ * Telemetry for the experimentation service.
+ */
+export interface IExperimentationTelemetry {
+	/**
+	 * Set shared property for all events.
+	 * @param name The name of the shared property.
+	 * @param value The value of the shared property.
+	 */
+	setSharedProperty(name: string, value: string): void;
+	/**
+	 * Posts an event into the telemetry implementation.
+	 */
+	postEvent(eventName: string, props: Map<string, string>): void;
+}
+
+export const ITelemetryUserConfig = createServiceIdentifier<ITelemetryUserConfig>('ITelemetryUserConfig');
+
+export interface ITelemetryUserConfig {
+	readonly _serviceBrand: undefined;
+	trackingId: string | undefined;
+	organizationsList: string | undefined;
+	optedIn: boolean;
+}
+
+export class TelemetryUserConfigImpl implements ITelemetryUserConfig {
+	declare readonly _serviceBrand: undefined;
+	// tracking id from auth token
+	public trackingId: string | undefined;
+	public organizationsList: string | undefined;
+	public optedIn: boolean;
+
+	constructor(
+		trackingId: string | undefined,
+		optedIn: boolean | undefined,
+		@ICopilotTokenStore private readonly _tokenStore: ICopilotTokenStore,
+	) {
+		this.trackingId = trackingId;
+		this.optedIn = optedIn ?? false;
+		this.setupUpdateOnToken();
+	}
+
+	private setupUpdateOnToken() {
+		this._tokenStore.onDidStoreUpdate(() => {
+			const token = this._tokenStore.copilotToken;
+			if (!token) {
+				return;
+			}
+			const enhancedTelemetry = token.getTokenValue('rt') === '1';
+			const trackingId = token.getTokenValue('tid');
+			if (trackingId !== undefined) {
+				this.trackingId = trackingId;
+				this.organizationsList = token.organizationList.toString();
+				this.optedIn = enhancedTelemetry;
+			}
+		});
+	}
+}
+
+export type TelemetryProperties = { [key: string]: string };
+
+export type AdditionalTelemetryProperties = { [key: string]: string };
+
+export type TelemetryDestination = {
+	github: boolean | { eventNamePrefix: string };
+	microsoft: boolean;
+};
+
+export interface ITelemetryService extends IExperimentationTelemetry, IDisposable {
+	readonly _serviceBrand: undefined;
+	/**
+	 * Send a Microsoft internal telemetry event.
+	 *
+	 * @remark This is a no-op if the user is not part of an allowed organization.
+	 * @remark This event does not require GDPR comments due to being classified in a special manner for internal use only.
+
+	 */
+	sendInternalMSFTTelemetryEvent(eventName: string, properties?: TelemetryEventProperties, measurements?: TelemetryEventMeasurements): void;
+	sendMSFTTelemetryEvent(eventName: string, properties?: TelemetryEventProperties, measurements?: TelemetryEventMeasurements): void;
+	sendMSFTTelemetryErrorEvent(eventName: string, properties?: TelemetryEventProperties, measurements?: TelemetryEventMeasurements): void;
+	sendGHTelemetryEvent(eventName: string, properties?: TelemetryEventProperties, measurements?: TelemetryEventMeasurements): void;
+	sendGHTelemetryErrorEvent(eventName: string, properties?: TelemetryEventProperties, measurements?: TelemetryEventMeasurements): void;
+	sendGHTelemetryException(maybeError: unknown, origin: string): void;
+	sendEnhancedGHTelemetryEvent(eventName: string, properties?: TelemetryEventProperties, measurements?: TelemetryEventMeasurements): void;
+	sendEnhancedGHTelemetryErrorEvent(eventName: string, properties?: TelemetryEventProperties, measurements?: TelemetryEventMeasurements): void;
+	sendTelemetryEvent(eventName: string, destination: TelemetryDestination, properties?: TelemetryEventProperties, measurements?: TelemetryEventMeasurements): void;
+	sendTelemetryEvent<TTelemetryEvent extends ITelemetryEvent>(eventName: TTelemetryEvent['eventName'], destination: TelemetryDestination, properties?: TTelemetryEvent['properties'], measurements?: TTelemetryEvent['measurements']): void;
+	sendTelemetryErrorEvent(eventName: string, destination: TelemetryDestination, properties?: TelemetryEventProperties, measurements?: TelemetryEventMeasurements): void;
+}
+
+export interface ITelemetryEvent {
+	eventName: string;
+	properties?: object;
+	measurements?: object;
+}
+
+/**
+ * The "sub services" which power the telemetry service and send telemetry to the appropriate endpoints.
+ */
+export interface ITelemetrySender extends IDisposable {
+	sendTelemetryEvent(eventName: string, properties?: TelemetryEventProperties, measurements?: TelemetryEventMeasurements): void;
+	sendTelemetryErrorEvent(eventName: string, properties?: TelemetryEventProperties, measurements?: TelemetryEventMeasurements): void;
+}
+
+export const ITelemetryService = createServiceIdentifier<ITelemetryService>('ITelemetryService');
+export interface IMSFTTelemetrySender extends ITelemetrySender {
+	/**
+	 * Send a Microsoft internal telemetry event.
+	 *
+	 * @remark This is a no-op if the user is not part of an allowed organization.
+	 * @remark This event does not require GDPR comments due to be classified in a special manner for internal use only.
+	 */
+	sendInternalTelemetryEvent(eventName: string, properties?: TelemetryEventProperties, measurements?: TelemetryEventMeasurements): void;
+}
+export interface IGHTelemetryService {
+	readonly _serviceBrand: undefined;
+	setSecureReporter(reporter: TelemetrySender | undefined): void;
+	setReporter(reporter: TelemetrySender | undefined): void;
+
+	/**
+	 * Standard telemetry events can be disabled with VS Code's telemetry settings.
+	 */
+	sendTelemetry(name: string, telemetryData?: TelemetryData): Promise<void>;
+
+	/**
+	 * Standard telemetry events can be disabled with VS Code's telemetry settings.
+	 */
+	sendErrorTelemetry(name: string, telemetryData?: TelemetryData): Promise<void>;
+
+	/**
+	 * Enhanced telemetry events contain additional data such as user prompts and suggestions. Like standard telemetry events, it can disabled with VS Code's telemetry settings or the Copilot settings page.
+	 *
+	 * You can manage this setting on the Copilot settings page https://github.com/settings/copilot/features
+	 * Learn about configuring this telemetry at https://docs.github.com/en/copilot/managing-copilot/managing-copilot-as-an-individual-subscriber/managing-your-copilot-plan/managing-copilot-policies-as-an-individual-subscriber#enabling-or-disabling-prompt-and-suggestion-collection
+	 * Learn more about the data collected at https://github.com/features/copilot/#faq
+	 */
+	sendEnhancedTelemetry(name: string, telemetryData?: TelemetryData): Promise<void>;
+
+	/**
+	 * Enhanced telemetry events contain additional data such as user prompts and suggestions. Like standard telemetry events, it can disabled with VS Code's telemetry settings or the Copilot settings page.
+	 *
+	 * You can manage this setting on the Copilot settings page https://github.com/settings/copilot/features
+	 * Learn about configuring this telemetry at https://docs.github.com/en/copilot/managing-copilot/managing-copilot-as-an-individual-subscriber/managing-your-copilot-plan/managing-copilot-policies-as-an-individual-subscriber#enabling-or-disabling-prompt-and-suggestion-collection
+	 * Learn more about the data collected at https://github.com/features/copilot/#faq
+	 */
+	sendEnhancedErrorTelemetry(name: string, telemetryData?: TelemetryData): Promise<void>;
+
+	sendExpProblemTelemetry(telemetryProperties: { reason: string }): Promise<void>;
+	sendExceptionTelemetry(maybeError: unknown, origin: string): Promise<void>;
+	deactivate(): Promise<void>;
+}
+
+/**
+ * Borrowed from https://github.com/microsoft/vscode/blob/9e560ad042bbc97e98f241f58cd08ddde0458a30/src/vs/platform/telemetry/common/telemetryUtils.ts#L21-L25
+ * Used as an API type in the vscode.d.ts as well to indicate properties that are exempt from cleaning.
+ */
+export class TelemetryTrustedValue<T> {
+	// This is merely used as an identifier as the instance will be lost during serialization over the exthost
+	public readonly isTrustedTelemetryValue = true;
+	constructor(public readonly value: T) { }
+}
+
+// From Copilot extension.
+
+const MAX_PROPERTY_LENGTH = 8192;
+const MAX_CONCATENATED_PROPERTIES = 50; // 50 properties of 8192 characters each is 409600 characters.
+
+export function multiplexProperties(properties: { [key: string]: string | undefined }): { [key: string]: string | undefined } {
+	const newProperties = { ...properties };
+	for (const key in properties) {
+		const value = properties[key];
+		// Test the length of value
+		let remainingValueCharactersLength = value?.length ?? 0;
+		if (remainingValueCharactersLength > MAX_PROPERTY_LENGTH) {
+			let lastStartIndex = 0;
+			let newPropertiesCount = 0;
+			while (remainingValueCharactersLength > 0 && newPropertiesCount < MAX_CONCATENATED_PROPERTIES) {
+				newPropertiesCount += 1;
+				let propertyName = key;
+				if (newPropertiesCount > 1) {
+					propertyName = key + '_' + (newPropertiesCount < 10 ? '0' : '') + newPropertiesCount;
+				}
+				let offsetIndex = lastStartIndex + MAX_PROPERTY_LENGTH;
+				if (remainingValueCharactersLength < MAX_PROPERTY_LENGTH) {
+					offsetIndex = lastStartIndex + remainingValueCharactersLength;
+				}
+				newProperties[propertyName] = value!.slice(lastStartIndex, offsetIndex);
+				remainingValueCharactersLength -= MAX_PROPERTY_LENGTH;
+				lastStartIndex += MAX_PROPERTY_LENGTH;
+			}
+		}
+	}
+	return newProperties;
+}

package/src/_internal/platform/telemetry/common/telemetryData.ts

@@ -0,0 +1,205 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import type { TelemetryTrustedValue } from 'vscode';
+import { generateUuid } from '../../../util/vs/base/common/uuid';
+import { IConfigurationService } from '../../configuration/common/configurationService';
+import { IEnvService } from '../../env/common/envService';
+import { RequestId } from '../../networking/common/fetch';
+import { ITelemetryUserConfig, TelemetryEventProperties, TelemetryProperties } from './telemetry';
+
+export class TelemetryData {
+
+	properties: TelemetryProperties;
+	measurements: { [key: string]: number | undefined };
+	issuedTime: number;
+	displayedTime?: number;
+
+	private static keysExemptedFromSanitization: string[] = [
+		'VSCode.ABExp.Features',
+		'abexp.assignmentcontext',
+	];
+
+	private constructor(
+		properties: { [key: string]: string },
+		measurements: { [key: string]: number | undefined },
+		issuedTime: number
+	) {
+		this.properties = properties;
+		this.measurements = measurements;
+		this.issuedTime = issuedTime;
+	}
+
+	static createAndMarkAsIssued(
+		properties?: { [key: string]: string },
+		measurements?: { [key: string]: number | undefined }
+	): TelemetryData {
+		return new TelemetryData(properties || {}, measurements || {}, Date.now());
+	}
+
+	/**
+	 * @param properties new properties, which will overwrite old ones in case of a clash
+	 * @param measurements new measurements, which will overwrite old ones in case of a clash
+	 * @returns a TelemetryData object whose contents extend (copies of) the current one's and whose creation date is not updated
+	 */
+	extendedBy(properties?: TelemetryProperties, measurements?: { [key: string]: number | undefined }): TelemetryData {
+		const newProperties = { ...this.properties, ...properties };
+		const newMeasurements = { ...this.measurements, ...measurements };
+		const newData = new TelemetryData(newProperties, newMeasurements, this.issuedTime);
+		newData.displayedTime = this.displayedTime;
+
+		return newData;
+	}
+
+	/**
+	 * registers current time as the point where this was displayed
+	 * (no-op if a display time is already registered)
+	 */
+	markAsDisplayed(): void {
+		if (this.displayedTime === undefined) {
+			this.displayedTime = Date.now();
+		}
+	}
+
+	extendWithEditorAgnosticFields(envService: IEnvService): void {
+		this.properties['editor_version'] = envService.getEditorInfo().format();
+		this.properties['editor_plugin_version'] = envService.getEditorPluginInfo().format();
+		this.properties['client_machineid'] = envService.machineId;
+		this.properties['client_sessionid'] = envService.sessionId;
+		this.properties['copilot_version'] = `copilot/${envService.getVersion()}`;
+
+		this.properties['common_extname'] = envService.getEditorPluginInfo().name;
+		this.properties['common_extversion'] = envService.getEditorPluginInfo().version;
+		this.properties['common_vscodeversion'] = envService.getEditorInfo().format();
+	}
+
+	/**
+	 * Iterate config keys defined in the package.json, lookup current config
+	 * value and return as telemetry property. Property name in dotted notation
+	 * and value is a json string.
+	 * e.g. { 'copilot.autocompletion.count': 3 }
+	 */
+	extendWithConfigProperties(configService: IConfigurationService, envService: IEnvService, telemetryConfig: ITelemetryUserConfig): void {
+		const configProperties: { [key: string]: string } = configService.dumpConfig();
+		configProperties['copilot.build'] = envService.getBuild();
+		configProperties['copilot.buildType'] = envService.getBuildType();
+
+		if (telemetryConfig.trackingId) {
+			configProperties['copilot.trackingId'] = telemetryConfig.trackingId;
+		}
+		if (telemetryConfig.organizationsList) {
+			configProperties['organizations_list'] = telemetryConfig.organizationsList;
+		}
+
+		// By being the second argument, configProperties will always override
+		this.properties = { ...this.properties, ...configProperties };
+	}
+
+	extendWithRequestId(requestId: RequestId): void {
+		const requestProperties = {
+			completionId: requestId.completionId,
+			created: requestId.created.toString(),
+			headerRequestId: requestId.headerRequestId,
+			serverExperiments: requestId.serverExperiments,
+			deploymentId: requestId.deploymentId,
+		};
+		this.properties = { ...this.properties, ...requestProperties };
+	}
+
+	private static keysToRemoveFromStandardTelemetry: string[] = [
+		'gitRepoHost',
+		'gitRepoName',
+		'gitRepoOwner',
+		'gitRepoUrl',
+		'gitRepoPath',
+		'repo',
+		'request_option_nwo',
+		'userKind',
+	];
+
+	/**
+	 * Remove the known properties relating to repository information from the telemetry data if necessary
+	 */
+	static maybeRemoveRepoInfoFromPropertiesHack(secure: boolean, map: { [key: string]: any }): { [key: string]: any } {
+		if (secure) {
+			// We want to keep including these properties in secure/enhanced telemetry.
+			return map;
+		}
+		// deliberately written in the same style as `sanitizeKeys` to minimise risk
+		const returnValue: { [key: string]: any } = {};
+		for (const key in map) {
+			if (!TelemetryData.keysToRemoveFromStandardTelemetry.includes(key)) {
+				returnValue[key] = map[key];
+			}
+		}
+		return returnValue;
+	}
+
+	sanitizeKeys(): void {
+		this.properties = TelemetryData.sanitizeKeys(this.properties);
+		this.measurements = TelemetryData.sanitizeKeys(this.measurements);
+	}
+
+	static sanitizeKeys(map?: { [key: string]: any }): { [key: string]: any } {
+		// We need all keys to not have dots in them for telemetry to function
+		map = map || {};
+		const returnValue: { [key: string]: any } = {};
+		// Iterate over all keys in the map and replace dots with underscores
+		for (const key in map) {
+			const newKey = TelemetryData.keysExemptedFromSanitization.includes(key) ? key : key.replace(/\./g, '_');
+			returnValue[newKey] = map[key];
+		}
+		return returnValue;
+	}
+
+	updateTimeSinceIssuedAndDisplayed(): void {
+		const timeSinceIssued = Date.now() - this.issuedTime;
+		this.measurements.timeSinceIssuedMs = timeSinceIssued;
+
+		if (this.displayedTime !== undefined) {
+			const timeSinceDisplayed = Date.now() - this.displayedTime;
+			this.measurements.timeSinceDisplayedMs = timeSinceDisplayed;
+		}
+	}
+
+	makeReadyForSending(configService: IConfigurationService, envService: IEnvService, telemetryConfig: ITelemetryUserConfig) {
+		this.extendWithConfigProperties(configService, envService, telemetryConfig);
+		this.extendWithEditorAgnosticFields(envService);
+		this.sanitizeKeys();
+		this.updateTimeSinceIssuedAndDisplayed();
+		// Remove undefined values from the telemetry data
+		for (const key in this.properties) {
+			if (this.properties[key] === undefined) {
+				delete this.properties[key];
+			}
+		}
+		addRequiredProperties(envService, this.properties);
+	}
+}
+
+export function eventPropertiesToSimpleObject(properties?: TelemetryEventProperties): TelemetryProperties | undefined {
+	if (!properties) {
+		return;
+	}
+	const simpleObject: TelemetryProperties = {};
+	for (const key in properties) {
+		const value = properties[key];
+		if (!value) {
+			continue;
+		}
+		if ((value as TelemetryTrustedValue<string>).value) {
+			simpleObject[key] = (value as TelemetryTrustedValue<string>).value;
+		} else {
+			simpleObject[key] = value as string;
+		}
+	}
+	return simpleObject;
+}
+
+function addRequiredProperties(envService: IEnvService, properties: { [key: string]: string }) {
+	properties['unique_id'] = generateUuid(); // add a unique id to the telemetry event so copilot-foundations can correlate with duplicate events
+	properties['common_extname'] = envService.getEditorPluginInfo().name;
+	properties['common_extversion'] = envService.getEditorPluginInfo().version;
+	properties['common_vscodeversion'] = envService.getEditorInfo().format();
+}

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

@@ -0,0 +1,61 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export interface ThinkingDataInMessage {
+	// Azure Open AI fields for Completions
+	cot_id?: string;
+	cot_summary?: string;
+
+	// Copilot API fields for Completions
+	reasoning_opaque?: string;
+	reasoning_text?: string;
+}
+
+export interface RawThinkingDelta {
+	// Azure Open AI fields
+	cot_id?: string;
+	cot_summary?: string;
+
+	// Copilot API fields
+	reasoning_opaque?: string;
+	reasoning_text?: string;
+
+	// Anthropic fields
+	thinking?: string;
+	signature?: string;
+}
+
+export type ThinkingDelta = {
+	text?: string | string[];
+	id: string;
+	metadata?: { readonly [key: string]: any };
+} | {
+	text?: string | string[];
+	id?: string;
+	metadata: { readonly [key: string]: any };
+} |
+{
+	text: string | string[];
+	id?: string;
+	metadata?: { readonly [key: string]: any };
+};
+
+export type EncryptedThinkingDelta = {
+	id: string;
+	text?: string;
+	encrypted: string;
+}
+
+export function isEncryptedThinkingDelta(delta: ThinkingDelta | EncryptedThinkingDelta): delta is EncryptedThinkingDelta {
+	return (delta as EncryptedThinkingDelta).encrypted !== undefined;
+}
+
+export interface ThinkingData {
+	id: string;
+	text: string | string[];
+	metadata?: { [key: string]: any };
+	tokens?: number;
+	encrypted?: string;
+}

package/src/_internal/platform/thinking/common/thinkingUtils.ts

@@ -0,0 +1,57 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { RawThinkingDelta, ThinkingDelta } from './thinking';
+
+function getThinkingDeltaText(thinking: RawThinkingDelta | undefined): string | undefined {
+	if (!thinking) {
+		return '';
+	}
+	if (thinking.cot_summary) {
+		return thinking.cot_summary;
+	}
+	if (thinking.reasoning_text) {
+		return thinking.reasoning_text;
+	}
+	if (thinking.thinking) {
+		return thinking.thinking;
+	}
+	return undefined;
+}
+
+function getThinkingDeltaId(thinking: RawThinkingDelta | undefined): string | undefined {
+	if (!thinking) {
+		return undefined;
+	}
+	if (thinking.cot_id) {
+		return thinking.cot_id;
+	}
+	if (thinking.reasoning_opaque) {
+		return thinking.reasoning_opaque;
+	}
+	if (thinking.signature) {
+		return thinking.signature;
+	}
+	return undefined;
+}
+
+export function extractThinkingDeltaFromChoice(choice: { message?: RawThinkingDelta; delta?: RawThinkingDelta }): ThinkingDelta | undefined {
+	const thinking = choice.message || choice.delta;
+	if (!thinking) {
+		return undefined;
+	}
+
+	const id = getThinkingDeltaId(thinking);
+	const text = getThinkingDeltaText(thinking);
+
+	if (id && text) {
+		return { id, text };
+	} else if (text) {
+		return { text };
+	} else if (id) {
+		return { id };
+	}
+	return undefined;
+}

package/src/_internal/platform/tokenizer/node/parseTikTokens.ts

@@ -0,0 +1,23 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { readFileSync } from 'fs';
+import { readVariableLengthQuantity } from '../../../util/common/variableLengthQuantity';
+import { VSBuffer } from '../../../util/vs/base/common/buffer';
+
+/** See `script/build/compressTikToken.ts` */
+export const parseTikTokenBinary = (file: string): Map<Uint8Array, number> => {
+	const contents = readFileSync(file);
+	const result = new Map<Uint8Array, number>();
+
+	for (let i = 0; i < contents.length;) {
+		const termLength = readVariableLengthQuantity(VSBuffer.wrap(contents), i);
+		i += termLength.consumed;
+		result.set(contents.subarray(i, i + termLength.value), result.size);
+		i += termLength.value;
+	}
+
+	return result;
+};