@vscode/chat-lib 0.0.1

package/src/_internal/util/common/test/shims/enums.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 enum InteractiveEditorResponseFeedbackKind {
+	Unhelpful = 0,
+	Helpful = 1,
+	Undone = 2,
+	Accepted = 3,
+	Bug = 4
+}
+
+export enum TextEditorCursorStyle {
+	Line = 1,
+	Block = 2,
+	Underline = 3,
+	LineThin = 4,
+	BlockOutline = 5,
+	UnderlineThin = 6
+}
+
+export enum TextEditorLineNumbersStyle {
+	Off = 0,
+	On = 1,
+	Relative = 2,
+	Interval = 3,
+}
+
+export enum TextEditorRevealType {
+	Default = 0,
+	InCenter = 1,
+	InCenterIfOutsideViewport = 2,
+	AtTop = 3
+}
+
+export enum DiagnosticSeverity {
+	Error = 0,
+	Warning = 1,
+	Information = 2,
+	Hint = 3
+}
+
+export enum ExtensionMode {
+	Production = 1,
+	Development = 2,
+	Test = 3,
+}
+
+export enum ChatVariableLevel {
+	Short = 1,
+	Medium = 2,
+	Full = 3
+}
+
+export enum ChatLocation {
+	Panel = 1,
+	Terminal = 2,
+	Notebook = 3,
+	Editor = 4,
+}

package/src/_internal/util/common/test/shims/l10n.ts

@@ -0,0 +1,37 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export function t(message: string, args: Record<string, any>): string;
+export function t(message: string, ...args: Array<string | number | boolean>): string;
+export function t(options: { message: string; args?: Array<string | number | boolean> | Record<string, any>; comment: string | string[] }): string;
+export function t(...params: [message: string, ...args: Array<string | number | boolean>] | [message: string, args: Record<string, any>] | [{ message: string; args?: Array<string | number | boolean> | Record<string, any>; comment: string | string[] }]): string {
+	if (typeof params[0] === 'string') {
+		const key = params.shift() as string;
+
+		// We have either rest args which are Array<string | number | boolean> or an array with a single Record<string, any>.
+		// This ensures we get a Record<string | number, any> which will be formatted correctly.
+		const argsFormatted = !params || typeof params[0] !== 'object' ? params : params[0];
+		return getMessage({ message: key, args: argsFormatted as Record<string | number, any> | undefined });
+	}
+
+	return getMessage(params[0]);
+}
+
+interface IStringDetails {
+	message: string;
+	args?: Record<string | number, any>;
+	comment?: string | string[];
+}
+
+function getMessage(details: IStringDetails): string {
+	const { message, args } = details;
+	return format2(message, (args ?? {}));
+}
+
+const _format2Regexp = /{([^}]+)}/g;
+
+function format2(template: string, values: Record<string, unknown>): string {
+	return template.replace(_format2Regexp, (match, group) => (values[group] ?? match) as string);
+}

package/src/_internal/util/common/test/shims/newSymbolName.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.
+ *--------------------------------------------------------------------------------------------*/
+
+export enum NewSymbolNameTag {
+	AIGenerated = 1
+}
+
+export enum NewSymbolNameTriggerKind {
+	Invoke = 0,
+	Automatic = 1,
+}
+
+export class NewSymbolName {
+	readonly newSymbolName: string;
+	readonly tags?: readonly NewSymbolNameTag[];
+
+	constructor(newSymbolName: string, tags?: readonly NewSymbolNameTag[]) {
+		this.newSymbolName = newSymbolName;
+		this.tags = tags;
+	}
+}

package/src/_internal/util/common/test/shims/terminal.ts

@@ -0,0 +1,33 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+
+export enum TerminalShellExecutionCommandLineConfidence {
+	/**
+	 * The command line value confidence is low. This means that the value was read from the
+	 * terminal buffer using markers reported by the shell integration script. Additionally one
+	 * of the following conditions will be met:
+	 *
+	 * - The command started on the very left-most column which is unusual, or
+	 * - The command is multi-line which is more difficult to accurately detect due to line
+	 *   continuation characters and right prompts.
+	 * - Command line markers were not reported by the shell integration script.
+	 */
+	Low = 0,
+
+	/**
+	 * The command line value confidence is medium. This means that the value was read from the
+	 * terminal buffer using markers reported by the shell integration script. The command is
+	 * single-line and does not start on the very left-most column (which is unusual).
+	 */
+	Medium = 1,
+
+	/**
+	 * The command line value confidence is high. This means that the value was explicitly sent
+	 * from the shell integration script or the command was executed via the
+	 * {@link TerminalShellIntegration.executeCommand} API.
+	 */
+	High = 2
+}

package/src/_internal/util/common/test/shims/vscodeTypesShim.ts

@@ -0,0 +1,115 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscodeTypes from '../../../../vscodeTypes';
+import { CancellationTokenSource } from '../../../vs/base/common/cancellation';
+import { Emitter as EventEmitter } from '../../../vs/base/common/event';
+import { URI as Uri } from '../../../vs/base/common/uri';
+import { Diagnostic, DiagnosticRelatedInformation } from '../../../vs/workbench/api/common/extHostTypes/diagnostic';
+import { Location } from '../../../vs/workbench/api/common/extHostTypes/location';
+import { MarkdownString } from '../../../vs/workbench/api/common/extHostTypes/markdownString';
+import { NotebookCellData, NotebookCellKind, NotebookData, NotebookEdit, NotebookRange } from '../../../vs/workbench/api/common/extHostTypes/notebooks';
+import { Position } from '../../../vs/workbench/api/common/extHostTypes/position';
+import { Range } from '../../../vs/workbench/api/common/extHostTypes/range';
+import { Selection } from '../../../vs/workbench/api/common/extHostTypes/selection';
+import { SymbolInformation } from '../../../vs/workbench/api/common/extHostTypes/symbolInformation';
+import { EndOfLine, TextEdit } from '../../../vs/workbench/api/common/extHostTypes/textEdit';
+import { AISearchKeyword, ChatErrorLevel, ChatImageMimeType, ChatPrepareToolInvocationPart, ChatReferenceBinaryData, ChatReferenceDiagnostic, ChatRequestEditedFileEventKind, ChatRequestEditorData, ChatRequestNotebookData, ChatRequestTurn, ChatResponseAnchorPart, ChatResponseClearToPreviousToolInvocationReason, ChatResponseCodeblockUriPart, ChatResponseCodeCitationPart, ChatResponseCommandButtonPart, ChatResponseConfirmationPart, ChatResponseExtensionsPart, ChatResponseFileTreePart, ChatResponseMarkdownPart, ChatResponseMarkdownWithVulnerabilitiesPart, ChatResponseMovePart, ChatResponseNotebookEditPart, ChatResponseProgressPart, ChatResponseProgressPart2, ChatResponsePullRequestPart, ChatResponseReferencePart, ChatResponseReferencePart2, ChatResponseTextEditPart, ChatResponseThinkingProgressPart, ChatResponseTurn, ChatResponseWarningPart, ExcludeSettingOptions, LanguageModelChatMessageRole, LanguageModelDataPart, LanguageModelDataPart2, LanguageModelPartAudience, LanguageModelPromptTsxPart, LanguageModelTextPart, LanguageModelTextPart2, LanguageModelToolCallPart, LanguageModelToolExtensionSource, LanguageModelToolMCPSource, LanguageModelToolResult, LanguageModelToolResult2, LanguageModelToolResultPart, LanguageModelToolResultPart2, TextSearchMatch2, ChatToolInvocationPart, ChatResponseTurn2 } from './chatTypes';
+import { TextDocumentChangeReason, TextEditorSelectionChangeKind, WorkspaceEdit } from './editing';
+import { ChatLocation, ChatVariableLevel, DiagnosticSeverity, ExtensionMode, TextEditorCursorStyle, TextEditorLineNumbersStyle, TextEditorRevealType } from './enums';
+import { t } from './l10n';
+import { NewSymbolName, NewSymbolNameTag, NewSymbolNameTriggerKind } from './newSymbolName';
+import { TerminalShellExecutionCommandLineConfidence } from './terminal';
+
+const shim: typeof vscodeTypes = {
+	Position,
+	Range,
+	Selection,
+	EventEmitter,
+	CancellationTokenSource,
+	Diagnostic,
+	Location,
+	DiagnosticRelatedInformation,
+	TextEdit,
+	WorkspaceEdit: <any>WorkspaceEdit,
+	Uri,
+	MarkdownString,
+	DiagnosticSeverity,
+	TextEditorCursorStyle,
+	TextEditorLineNumbersStyle,
+	TextEditorRevealType,
+	EndOfLine,
+	l10n: {
+		t
+	},
+	ExtensionMode,
+	ChatVariableLevel,
+	ChatResponseClearToPreviousToolInvocationReason,
+	ChatResponseMarkdownPart,
+	ChatResponseFileTreePart,
+	ChatResponseAnchorPart,
+	ChatResponseMovePart,
+	ChatResponseExtensionsPart,
+	ChatResponseProgressPart,
+	ChatResponseProgressPart2,
+	ChatResponseWarningPart,
+	ChatResponseReferencePart,
+	ChatResponseReferencePart2,
+	ChatResponseCodeCitationPart,
+	ChatResponseCommandButtonPart,
+	ChatResponseMarkdownWithVulnerabilitiesPart,
+	ChatResponseCodeblockUriPart,
+	ChatResponseTextEditPart,
+	ChatResponseNotebookEditPart,
+	ChatResponseConfirmationPart,
+	ChatPrepareToolInvocationPart,
+	ChatRequestTurn,
+	ChatResponseTurn,
+	ChatRequestEditorData,
+	ChatRequestNotebookData,
+	NewSymbolName,
+	NewSymbolNameTag,
+	NewSymbolNameTriggerKind,
+	ChatLocation,
+	SymbolInformation: SymbolInformation as any,
+	LanguageModelToolResult,
+	ExtendedLanguageModelToolResult: LanguageModelToolResult,
+	LanguageModelToolResult2,
+	LanguageModelPromptTsxPart,
+	LanguageModelTextPart,
+	LanguageModelDataPart,
+	LanguageModelToolExtensionSource,
+	LanguageModelToolMCPSource,
+	ChatImageMimeType,
+	ChatReferenceBinaryData,
+	ChatReferenceDiagnostic,
+	TextSearchMatch2,
+	AISearchKeyword,
+	ExcludeSettingOptions,
+	NotebookCellKind,
+	NotebookRange,
+	NotebookEdit,
+	NotebookCellData,
+	NotebookData,
+	ChatErrorLevel,
+	TerminalShellExecutionCommandLineConfidence,
+	ChatRequestEditedFileEventKind,
+	ChatResponsePullRequestPart,
+	LanguageModelTextPart2,
+	LanguageModelDataPart2,
+	LanguageModelPartAudience,
+	ChatResponseThinkingProgressPart,
+	LanguageModelToolCallPart,
+	LanguageModelToolResultPart,
+	LanguageModelToolResultPart2,
+	LanguageModelChatMessageRole,
+	TextEditorSelectionChangeKind,
+	TextDocumentChangeReason,
+	ChatToolInvocationPart,
+	ChatResponseTurn2,
+	ChatRequestTurn2: ChatRequestTurn
+};
+
+export = shim;

package/src/_internal/util/common/time.ts

@@ -0,0 +1,31 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/**
+ * Used for representing seconds into a human readable string like 6 hours and 50 minutes.
+ * This is primarily used to represent how long to wait for a rate limit.
+ * @param seconds The number of seconds to convert to a human readable string.
+ * @returns A human readable string representing the number of seconds.
+ */
+export function secondsToHumanReadableTime(seconds: number): string {
+	if (seconds < 90) {
+		return `${seconds} seconds`;
+	}
+
+	const minutes = Math.floor(seconds / 60);
+	if (seconds <= 5400) {
+		return `${minutes} minutes`;
+	}
+
+	const hours = Math.floor(minutes / 60);
+	const remainingMinutes = minutes % 60;
+
+	let result = `${hours} hours`;
+	if (remainingMinutes > 0) {
+		result += ` ${remainingMinutes} minutes`;
+	}
+
+	return result;
+}

package/src/_internal/util/common/tokenizer.ts

@@ -0,0 +1,30 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import type { ITokenizer as ITsxTokenizer, OutputMode, Raw } from '@vscode/prompt-tsx';
+import type { LanguageModelChatTool } from 'vscode';
+
+
+export enum TokenizerType {
+	CL100K = 'cl100k_base',
+	O200K = 'o200k_base',
+	Llama3 = 'llama3',
+}
+
+export interface ITokenizer extends ITsxTokenizer<OutputMode.Raw> {
+
+	/**
+	 * Return the length of `text` in number of tokens.
+	 *
+	 * @param text The input text
+	 */
+	tokenLength(text: string | Raw.ChatCompletionContentPart): Promise<number>;
+
+	countMessageTokens(message: Raw.ChatMessage): Promise<number>;
+
+	countMessagesTokens(messages: Raw.ChatMessage[]): Promise<number>;
+
+	countToolTokens(tools: readonly LanguageModelChatTool[]): Promise<number>;
+}

package/src/_internal/util/common/tracing.ts

@@ -0,0 +1,52 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export interface ITracer {
+	trace(message: string, ...payload: unknown[]): void;
+	sub(name: string | string[]): ITracer;
+	throws(message?: string, ...payload: unknown[]): void;
+	returns(message?: string, ...payload: unknown[]): void;
+}
+
+export function createTracer(section: string | string[], logFn: (message: string) => void): ITracer {
+	const stringify = (value: unknown) => {
+		if (!value) {
+			return JSON.stringify(value);
+		}
+		if (typeof value === 'string') {
+			return value;
+		} else if (typeof value === 'object') {
+			const toStringValue = value.toString();
+			if (toStringValue && toStringValue !== '[object Object]') {
+				return toStringValue;
+			}
+			if (value instanceof Error) {
+				return value.stack || value.message;
+			}
+			return JSON.stringify(value, null, '\t');
+		}
+	};
+	const sectionStr = Array.isArray(section) ? section.join('][') : section;
+	return {
+		trace: (message: string, ...payload: unknown[]) => {
+			const payloadStr = payload.length ? ` ${stringify(payload)}` : '';
+			logFn(`[${sectionStr}] ${message}` + payloadStr);
+		},
+		sub: (name: string | string[]) => {
+			const subSection = Array.isArray(section) ? section.concat(name) : [section, ...(Array.isArray(name) ? name : [name])];
+			const sub = createTracer(subSection, logFn);
+			sub.trace('created');
+			return sub;
+		},
+		returns: (message?: string, ...payload: unknown[]) => {
+			const payloadStr = payload.length ? ` ${stringify(payload)}` : '';
+			logFn(`[${sectionStr}] Return: ${message ? message : 'void'}${payloadStr}`);
+		},
+		throws: (message?: string, ...payload: unknown[]) => {
+			const payloadStr = payload.length ? ` ${stringify(payload)}` : '';
+			logFn(`[${sectionStr}] Throw: ${message ? message : 'void'}${payloadStr}`);
+		}
+	};
+}

package/src/_internal/util/common/types.ts

@@ -0,0 +1,33 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import type * as vscode from '../../vscodeTypes';
+import { Location, Position, Range } from '../../util/common/test/shims/vscodeTypesShim';
+import { URI } from '../vs/base/common/uri';
+
+export function isUri(thing: any): thing is URI | vscode.Uri {
+	// This check works for URIs from vscode, but doesn't help with type narrowing on its own, so this function exists.
+	return URI.isUri(thing);
+}
+
+export function isLocation(obj: any): obj is vscode.Location {
+	return obj && typeof obj === 'object' && 'uri' in obj && 'range' in obj;
+}
+
+export function toLocation(obj: any) {
+	if (isLocation(obj) && Array.isArray(obj.range) && obj.range.length === 2) {
+		// HACK: prompt-tsx returns serialized ranges/positions that need to be converted back into real objects
+		const start = obj.range[0];
+		const end = obj.range[1];
+		return new Location(obj.uri, new Range(new Position(start.line, start.character), new Position(end.line, end.character)));
+	} else if (isLocation(obj) && obj.range instanceof Range) {
+		return obj;
+	}
+	return undefined;
+}
+
+export function isSymbolInformation(obj: any): obj is vscode.SymbolInformation {
+	return obj && typeof obj === 'object' && 'name' in obj && 'containerName' in obj;
+}

package/src/_internal/util/common/variableLengthQuantity.ts

@@ -0,0 +1,40 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { VSBuffer } from '../vs/base/common/buffer';
+
+/** Reads a 32-bit integer from the buffer */
+export function readVariableLengthQuantity(buffer: VSBuffer, offset: number): { value: number; consumed: number } {
+	let result = 0;
+	let consumed = 0;
+	let byte: number;
+
+	do {
+		byte = buffer.readUInt8(offset + consumed);
+		result |= (byte & 0x7f) << (consumed * 7);
+		consumed++;
+	} while (byte & 0x80);
+
+	return { value: result, consumed };
+}
+
+/** Writes a 32 bit integer to the buffer */
+export function writeVariableLengthQuantity(i: number): VSBuffer {
+	if (i !== (i | 0)) {
+		throw new Error(`${i} is not an int32.`);
+	}
+
+	const result: number[] = [];
+	do {
+		let byte = i & 0x7f;
+		i >>>= 7;
+		if (i !== 0) {
+			byte |= 0x80;
+		}
+		result.push(byte);
+	} while (i !== 0);
+
+	return VSBuffer.fromByteArray(result);
+}

package/src/_internal/util/node/worker.ts

@@ -0,0 +1,130 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Worker, WorkerOptions } from 'worker_threads';
+
+export type RpcRequest = { id: number; fn: string; args: any[] };
+
+export type RpcResponse = { id: number; res?: any; err?: Error };
+
+/**
+ * Holds promises for RPC requests and resolves them when the call completes.
+ */
+export class RcpResponseHandler {
+	private nextId = 1;
+
+	private readonly handlers = new Map<number, { resolve: (res: any) => void; reject: (err: Error) => void }>();
+
+	public createHandler<T>(): { id: number; result: Promise<T> } {
+		const id = this.nextId++;
+		let resolve: (res: any) => void;
+		let reject: (err: Error) => void;
+		const result = new Promise<any>((res, rej) => {
+			resolve = res;
+			reject = rej;
+		});
+		this.handlers.set(id, { resolve: resolve!, reject: reject! });
+		return { id, result };
+	}
+
+	public handleResponse(response: RpcResponse) {
+		const handler = this.handlers.get(response.id);
+		if (!handler) {
+			return;
+		}
+
+		this.handlers.delete(response.id);
+		if (response.err) {
+			handler.reject(response.err);
+		} else {
+			handler.resolve(response.res);
+		}
+	}
+
+	/**
+	 * Handle an unexpected error by logging it and rejecting all handlers.
+	 */
+	public handleError(err: Error) {
+		for (const handler of this.handlers.values()) {
+			handler.reject(err);
+		}
+		this.handlers.clear();
+	}
+
+	public clear() {
+		this.handlers.clear();
+	}
+}
+
+export type RpcProxy<ProxyType> = {
+	[K in keyof ProxyType]: ProxyType[K] extends ((...args: infer Args) => infer R) ? (...args: Args) => Promise<Awaited<R>> : never;
+}
+
+export function createRpcProxy<ProxyType>(remoteCall: (name: string, args: any[]) => Promise<any>): RpcProxy<ProxyType> {
+	const handler = {
+		get: (target: any, name: PropertyKey) => {
+			if (typeof name === 'string' && !target[name]) {
+				target[name] = (...myArgs: any[]) => {
+					return remoteCall(name, myArgs);
+				};
+			}
+			return target[name];
+		}
+	};
+	return new Proxy(Object.create(null), handler);
+}
+
+export class WorkerWithRpcProxy<WorkerProxyType, HostProxyType = {}> {
+	private readonly worker: Worker;
+	private readonly responseHandler = new RcpResponseHandler();
+
+	public readonly proxy: RpcProxy<WorkerProxyType>;
+
+	constructor(workerPath: string, workerOptions?: WorkerOptions, host?: HostProxyType) {
+		this.worker = new Worker(workerPath, workerOptions);
+		this.worker.on('message', async (msg: RpcRequest | RpcResponse) => {
+			if ('fn' in msg) {
+				try {
+					const response = await (host as any)?.[msg.fn].apply(host, msg.args);
+					this.worker.postMessage({ id: msg.id, res: response } satisfies RpcResponse);
+				} catch (err) {
+					this.worker.postMessage({ id: msg.id, err } satisfies RpcResponse);
+				}
+			} else {
+				this.responseHandler.handleResponse(msg);
+			}
+		});
+		this.worker.on('error', (err) => this.handleError(err));
+
+		this.worker.on('exit', code => {
+			if (code !== 0) {
+				this.handleError(new Error(`Worker thread exited with code ${code}.`));
+			}
+		});
+
+		this.proxy = createRpcProxy((fn: string, args: any[]): Promise<any> => {
+			if (!this.worker) {
+				throw new Error(`Worker was terminated!`);
+			}
+
+			const { id, result } = this.responseHandler.createHandler<any>();
+			this.worker.postMessage({ id, fn, args } satisfies RpcRequest);
+			return result;
+		});
+	}
+
+	terminate() {
+		this.worker.removeAllListeners();
+		this.worker.terminate();
+		this.responseHandler.clear();
+	}
+
+	/**
+	 * Handle an unexpected error by logging it and rejecting all handlers.
+	 */
+	private handleError(err: Error) {
+		this.responseHandler.handleError(err);
+	}
+}