@vscode/chat-lib 0.0.1

package/package.json

@@ -0,0 +1,64 @@
+{
+	"name": "@vscode/chat-lib",
+	"version": "0.0.1",
+	"description": "Chat and inline editing SDK extracted from VS Code Copilot Chat",
+	"main": "dist/src/main.js",
+	"types": "dist/src/main.d.ts",
+	"author": "Microsoft Corporation",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/microsoft/vscode-remote-containers.git"
+	},
+	"license": "SEE LICENSE IN LICENSE.txt",
+	"engines": {
+		"node": ">=22.14.0"
+	},
+	"dependencies": {
+		"@microsoft/tiktokenizer": "^1.0.10",
+		"@vscode/copilot-api": "^0.1.5",
+		"@vscode/l10n": "^0.0.18",
+		"@vscode/prompt-tsx": "^0.4.0-alpha.5",
+		"jsonc-parser": "^3.3.1",
+		"openai": "^5.11.0",
+		"web-tree-sitter": "^0.23.0",
+		"yaml": "^2.8.0"
+	},
+	"devDependencies": {
+		"@types/node": "^22.16.3",
+		"@types/vscode": "^1.102.0",
+		"copyfiles": "^2.4.1",
+		"dotenv": "^17.2.1",
+		"npm-run-all": "^4.1.5",
+		"outdent": "^0.8.0",
+		"rimraf": "^6.0.1",
+		"typescript": "^5.0.0",
+		"vitest": "^2.0.0"
+	},
+	"keywords": [
+		"chat",
+		"ai",
+		"sdk",
+		"vscode",
+		"copilot"
+	],
+	"files": [
+		"dist/src",
+		"src",
+		"README.md",
+		"LICENSE.txt",
+		"!src/**/*.tiktoken",
+		"!**/test/**",
+		"dist/src/_internal/util/common/test/shims",
+		"src/_internal/util/common/test/shims"
+	],
+	"scripts": {
+		"clean": "rimraf dist",
+		"build": "npm-run-all compile copy",
+		"compile": "tsc",
+		"copy": "copyfiles src/package.json \"src/**/*.tiktoken\" dist",
+		"package": "npm pack",
+		"publish": "npm publish",
+		"test": "vitest run",
+		"test:watch": "vitest"
+	}
+}

package/src/_internal/extension/byok/node/openAIEndpoint.ts

@@ -0,0 +1,171 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { IAuthenticationService } from '../../../platform/authentication/common/authentication';
+import { IChatMLFetcher } from '../../../platform/chat/common/chatMLFetcher';
+import { ChatFetchResponseType, ChatResponse } from '../../../platform/chat/common/commonTypes';
+import { IConfigurationService } from '../../../platform/configuration/common/configurationService';
+import { ICAPIClientService } from '../../../platform/endpoint/common/capiClient';
+import { IDomainService } from '../../../platform/endpoint/common/domainService';
+import { IChatModelInformation } from '../../../platform/endpoint/common/endpointProvider';
+import { ChatEndpoint } from '../../../platform/endpoint/node/chatEndpoint';
+import { IEnvService } from '../../../platform/env/common/envService';
+import { ILogService } from '../../../platform/log/common/logService';
+import { isOpenAiFunctionTool } from '../../../platform/networking/common/fetch';
+import { IFetcherService } from '../../../platform/networking/common/fetcherService';
+import { createCapiRequestBody, IChatEndpoint, ICreateEndpointBodyOptions, IEndpointBody, IMakeChatRequestOptions } from '../../../platform/networking/common/networking';
+import { RawMessageConversionCallback } from '../../../platform/networking/common/openai';
+import { IExperimentationService } from '../../../platform/telemetry/common/nullExperimentationService';
+import { ITelemetryService } from '../../../platform/telemetry/common/telemetry';
+import { ITokenizerProvider } from '../../../platform/tokenizer/node/tokenizer';
+import { IInstantiationService } from '../../../util/vs/platform/instantiation/common/instantiation';
+
+function hydrateBYOKErrorMessages(response: ChatResponse): ChatResponse {
+	if (response.type === ChatFetchResponseType.Failed && response.streamError) {
+		return {
+			type: response.type,
+			requestId: response.requestId,
+			serverRequestId: response.serverRequestId,
+			reason: JSON.stringify(response.streamError),
+		};
+	} else if (response.type === ChatFetchResponseType.RateLimited) {
+		return {
+			type: response.type,
+			requestId: response.requestId,
+			serverRequestId: response.serverRequestId,
+			reason: response.capiError ? 'Rate limit exceeded\n\n' + JSON.stringify(response.capiError) : 'Rate limit exceeded',
+			rateLimitKey: '',
+			retryAfter: undefined,
+			capiError: response.capiError
+		};
+	}
+	return response;
+}
+
+export class OpenAIEndpoint extends ChatEndpoint {
+	constructor(
+		protected readonly modelMetadata: IChatModelInformation,
+		protected readonly _apiKey: string,
+		protected readonly _modelUrl: string,
+		@IFetcherService fetcherService: IFetcherService,
+		@IDomainService domainService: IDomainService,
+		@ICAPIClientService capiClientService: ICAPIClientService,
+		@IEnvService envService: IEnvService,
+		@ITelemetryService telemetryService: ITelemetryService,
+		@IAuthenticationService authService: IAuthenticationService,
+		@IChatMLFetcher chatMLFetcher: IChatMLFetcher,
+		@ITokenizerProvider tokenizerProvider: ITokenizerProvider,
+		@IInstantiationService protected instantiationService: IInstantiationService,
+		@IConfigurationService configurationService: IConfigurationService,
+		@IExperimentationService expService: IExperimentationService,
+		@ILogService logService: ILogService
+	) {
+		super(
+			modelMetadata,
+			domainService,
+			capiClientService,
+			fetcherService,
+			envService,
+			telemetryService,
+			authService,
+			chatMLFetcher,
+			tokenizerProvider,
+			instantiationService,
+			configurationService,
+			expService,
+			logService
+		);
+	}
+
+	override createRequestBody(options: ICreateEndpointBodyOptions): IEndpointBody {
+		if (this.useResponsesApi) {
+			// Handle Responses API: customize the body directly
+			options.ignoreStatefulMarker = false;
+			const body = super.createRequestBody(options);
+			body.store = true;
+			body.n = undefined;
+			body.stream_options = undefined;
+			if (!this.modelMetadata.capabilities.supports.thinking) {
+				body.reasoning = undefined;
+			}
+			return body;
+		} else {
+			// Handle CAPI: provide callback for thinking data processing
+			const callback: RawMessageConversionCallback = (out, data) => {
+				if (data && data.id) {
+					out.cot_id = data.id;
+					out.cot_summary = Array.isArray(data.text) ? data.text.join('') : data.text;
+				}
+			};
+			const body = createCapiRequestBody(options, this.model, callback);
+			return body;
+		}
+	}
+
+	override interceptBody(body: IEndpointBody | undefined): void {
+		super.interceptBody(body);
+		// TODO @lramos15 - We should do this for all models and not just here
+		if (body?.tools?.length === 0) {
+			delete body.tools;
+		}
+
+		if (body?.tools) {
+			body.tools = body.tools.map(tool => {
+				if (isOpenAiFunctionTool(tool) && tool.function.parameters === undefined) {
+					tool.function.parameters = { type: "object", properties: {} };
+				}
+				return tool;
+			});
+		}
+
+		if (body) {
+			if (this.modelMetadata.capabilities.supports.thinking) {
+				delete body.temperature;
+				body['max_completion_tokens'] = body.max_tokens;
+				delete body.max_tokens;
+			}
+			// Removing max tokens defaults to the maximum which is what we want for BYOK
+			delete body.max_tokens;
+			if (!this.useResponsesApi) {
+				body['stream_options'] = { 'include_usage': true };
+			}
+		}
+	}
+
+	override get urlOrRequestMetadata(): string {
+		return this._modelUrl;
+	}
+
+	public getExtraHeaders(): Record<string, string> {
+		const headers: Record<string, string> = {
+			"Content-Type": "application/json"
+		};
+		if (this._modelUrl.includes('openai.azure')) {
+			headers['api-key'] = this._apiKey;
+		} else {
+			headers['Authorization'] = `Bearer ${this._apiKey}`;
+		}
+		return headers;
+	}
+
+	override async acceptChatPolicy(): Promise<boolean> {
+		return true;
+	}
+
+	override cloneWithTokenOverride(modelMaxPromptTokens: number): IChatEndpoint {
+		const newModelInfo = { ...this.modelMetadata, maxInputTokens: modelMaxPromptTokens };
+		return this.instantiationService.createInstance(OpenAIEndpoint, newModelInfo, this._apiKey, this._modelUrl);
+	}
+
+	public override async makeChatRequest2(options: IMakeChatRequestOptions, token: CancellationToken): Promise<ChatResponse> {
+		// Apply ignoreStatefulMarker: false for initial request
+		const modifiedOptions: IMakeChatRequestOptions = { ...options, ignoreStatefulMarker: false };
+		let response = await super.makeChatRequest2(modifiedOptions, token);
+		if (response.type === ChatFetchResponseType.InvalidStatefulMarker) {
+			response = await this._makeChatRequest2({ ...options, ignoreStatefulMarker: true }, token);
+		}
+		return hydrateBYOKErrorMessages(response);
+	}
+}

package/src/_internal/extension/common/constants.ts

@@ -0,0 +1,90 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ChatLocation } from '../../platform/chat/common/commonTypes';
+
+export const enum Intent {
+	Explain = 'explain',
+	Review = 'review',
+	Tests = 'tests',
+	Fix = 'fix',
+	New = 'new',
+	NewNotebook = 'newNotebook',
+	notebookEditor = 'notebookEditor',
+	Search = 'search',
+	SemanticSearch = 'semanticSearch',
+	Terminal = 'terminal',
+	TerminalExplain = 'terminalExplain',
+	VSCode = 'vscode',
+	Workspace = 'workspace',
+	Unknown = 'unknown',
+	StartDebugging = 'startDebugging',
+	SetupTests = 'setupTests',
+	Editor = 'editor',
+	Doc = 'doc',
+	Edit = 'edit',
+	Edit2 = 'edit2',
+	Agent = 'editAgent',
+	Generate = 'generate',
+	SearchPanel = 'searchPanel',
+	SearchKeywords = 'searchKeywords',
+	AskAgent = 'askAgent',
+	ChatReplay = 'chatReplay'
+}
+
+export const GITHUB_PLATFORM_AGENT = 'github.copilot-dynamic.platform';
+
+// TODO@jrieken THIS IS WEIRD. We should read this from package.json
+export const agentsToCommands: Partial<Record<Intent, Record<string, Intent>>> = {
+	[Intent.Workspace]: {
+		'explain': Intent.Explain,
+		'edit': Intent.Edit,
+		'review': Intent.Review,
+		'tests': Intent.Tests,
+		'fix': Intent.Fix,
+		'new': Intent.New,
+		'newNotebook': Intent.NewNotebook,
+		'semanticSearch': Intent.SemanticSearch,
+		'setupTests': Intent.SetupTests,
+	},
+	[Intent.VSCode]: {
+		'search': Intent.Search,
+		'startDebugging': Intent.StartDebugging,
+	},
+	[Intent.Terminal]: {
+		'explain': Intent.TerminalExplain
+	},
+	[Intent.Editor]: {
+		'doc': Intent.Doc,
+		'fix': Intent.Fix,
+		'explain': Intent.Explain,
+		'review': Intent.Review,
+		'tests': Intent.Tests,
+		'edit': Intent.Edit,
+		'generate': Intent.Generate
+	},
+	[Intent.ChatReplay]: {
+		'chatReplay': Intent.ChatReplay
+	}
+};
+
+// TODO@roblourens gotta tighten up the terminology of "commands", "intents", etc...
+export function getAgentForIntent(intentId: Intent, location: ChatLocation): { agent: string; command?: string } | undefined {
+	if (Object.keys(agentsToCommands).includes(intentId)) {
+		return { agent: intentId };
+	}
+
+	for (const [agent, commands] of Object.entries(agentsToCommands)) {
+		if (location === ChatLocation.Editor && agent !== Intent.Editor) {
+			continue;
+		}
+
+		if (Object.values(commands).includes(intentId)) {
+			return { agent, command: intentId };
+		}
+	}
+}
+
+export const EXTENSION_ID = 'GitHub.copilot-chat';

package/src/_internal/extension/inlineEdits/common/delayer.ts

@@ -0,0 +1,108 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ConfigKey, IConfigurationService } from '../../../platform/configuration/common/configurationService';
+import { IExperimentationService } from '../../../platform/telemetry/common/nullExperimentationService';
+
+export class DelaySession {
+	private extraDebounce = 0;
+
+	constructor(
+		private baseDebounceTime: number,
+		private readonly expectedTotalTime: number | undefined,
+		private readonly providerInvocationTime: number = Date.now(),
+	) {
+	}
+
+	public setExtraDebounce(extraDebounce: number): void {
+		this.extraDebounce = extraDebounce;
+	}
+
+	getDebounceTime() {
+		const expectedDebounceTime = this.expectedTotalTime === undefined
+			? this.baseDebounceTime + this.extraDebounce
+			: Math.min(this.baseDebounceTime + this.extraDebounce, this.expectedTotalTime);
+
+		const timeAlreadySpent = Date.now() - this.providerInvocationTime;
+		const actualDebounceTime = Math.max(0, expectedDebounceTime - timeAlreadySpent);
+
+		return actualDebounceTime;
+	}
+
+	getArtificialDelay() {
+		if (this.expectedTotalTime === undefined) {
+			return 0;
+		}
+
+		const timeAlreadySpent = Date.now() - this.providerInvocationTime;
+		const delay = Math.max(0, this.expectedTotalTime - timeAlreadySpent);
+		return delay;
+	}
+}
+
+export class Delayer {
+
+	private _recentUserActions: { time: number; kind: 'accepted' | 'rejected' }[] = [];
+
+	constructor(
+		@IConfigurationService private readonly _configurationService: IConfigurationService,
+		@IExperimentationService private readonly _experimentationService: IExperimentationService,
+	) {
+	}
+
+	public createDelaySession(requestTime: number | undefined): DelaySession {
+		const baseDebounceTime = this._configurationService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsDebounce, this._experimentationService);
+
+		const backoffDebounceEnabled = this._configurationService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsBackoffDebounceEnabled, this._experimentationService);
+		const expectedTotalTime = backoffDebounceEnabled ? this._getExpectedTotalTime(baseDebounceTime) : undefined;
+
+		return new DelaySession(baseDebounceTime, expectedTotalTime, requestTime);
+	}
+
+	public handleAcceptance(): void {
+		this._recordUserAction('accepted');
+	}
+
+	public handleRejection(): void {
+		this._recordUserAction('rejected');
+	}
+
+	private _recordUserAction(kind: 'accepted' | 'rejected') {
+		this._recentUserActions.push({ time: Date.now(), kind });
+		// keep at most 10 user actions
+		this._recentUserActions = this._recentUserActions.slice(-10);
+	}
+
+	private _getExpectedTotalTime(baseDebounceTime: number): number {
+		const DEBOUNCE_DECAY_TIME_MS = 10 * 60 * 1000; // 10 minutes
+		const MAX_DEBOUNCE_TIME = 3000; // 3 seconds
+		const MIN_DEBOUNCE_TIME = 50; // 50 ms
+		const REJECTION_WEIGHT = 1.5;
+		const ACCEPTANCE_WEIGHT = 0.8;
+		const now = Date.now();
+		let multiplier = 1;
+
+		// Calculate impact of each action with time decay
+		for (const action of this._recentUserActions) {
+			const timeSinceAction = now - action.time;
+			if (timeSinceAction > DEBOUNCE_DECAY_TIME_MS) {
+				continue;
+			}
+
+			// Exponential decay: impact decreases as time passes
+			const decayFactor = Math.exp(-timeSinceAction / DEBOUNCE_DECAY_TIME_MS);
+			const actionWeight = action.kind === 'rejected' ? REJECTION_WEIGHT : ACCEPTANCE_WEIGHT;
+			multiplier *= 1 + ((actionWeight - 1) * decayFactor);
+		}
+
+		let debounceTime = baseDebounceTime * multiplier;
+
+		// Clamp the debounce time to reasonable bounds
+		debounceTime = Math.min(MAX_DEBOUNCE_TIME, Math.max(MIN_DEBOUNCE_TIME, debounceTime));
+
+		return debounceTime;
+	}
+
+}