@codingame/monaco-vscode-api 5.2.0 → 6.0.0

package/vscode-dts/vscode.proposed.chatParticipantAdditions.d.ts

@@ -5,55 +5,8 @@
 
 declare module 'vscode' {
 
-	/**
-	 * The location at which the chat is happening.
-	 */
-	export enum ChatLocation {
-		/**
-		 * The chat panel
-		 */
-		Panel = 1,
-		/**
-		 * Terminal inline chat
-		 */
-		Terminal = 2,
-		/**
-		 * Notebook inline chat
-		 */
-		Notebook = 3,
-		/**
-		 * Code editor inline chat
-		 */
-		Editor = 4
-	}
-
-	export interface ChatRequest {
-		/**
-		 * The attempt number of the request. The first request has attempt number 0.
-		 */
-		readonly attempt: number;
-
-		/**
-		 * If automatic command detection is enabled.
-		 */
-		readonly enableCommandDetection: boolean;
-
-		/**
-		 * The location at which the chat is happening. This will always be one of the supported values
-		 */
-		readonly location: ChatLocation;
-	}
-
 	export interface ChatParticipant {
 		onDidPerformAction: Event<ChatUserActionEvent>;
-		supportIssueReporting?: boolean;
-	}
-
-	export interface ChatErrorDetails {
-		/**
-		 * If set to true, the message content is completely hidden. Only ChatErrorDetails#message will be shown.
-		 */
-		responseIsRedacted?: boolean;
 	}
 
 	/**
@@ -102,11 +55,83 @@ declare module 'vscode' {
 		constructor(uri: Uri, edits: TextEdit | TextEdit[]);
 	}
 
+	export class ChatResponseConfirmationPart {
+		title: string;
+		message: string;
+		data: any;
+		constructor(title: string, message: string, data: any);
+	}
+
+	export type ExtendedChatResponsePart = ChatResponsePart | ChatResponseTextEditPart | ChatResponseDetectedParticipantPart | ChatResponseConfirmationPart;
+
+	export class ChatResponseWarningPart {
+		value: MarkdownString;
+		constructor(value: string | MarkdownString);
+	}
+
+	export class ChatResponseProgressPart2 extends ChatResponseProgressPart {
+		value: string;
+		task?: (progress: Progress<ChatResponseWarningPart | ChatResponseReferencePart>) => Thenable<string | void>;
+		constructor(value: string, task?: (progress: Progress<ChatResponseWarningPart | ChatResponseReferencePart>) => Thenable<string | void>);
+	}
+
 	export interface ChatResponseStream {
-		textEdit(target: Uri, edits: TextEdit | TextEdit[]): ChatResponseStream;
-		markdownWithVulnerabilities(value: string | MarkdownString, vulnerabilities: ChatVulnerability[]): ChatResponseStream;
-		detectedParticipant(participant: string, command?: ChatCommand): ChatResponseStream;
-		push(part: ChatResponsePart | ChatResponseTextEditPart | ChatResponseDetectedParticipantPart): ChatResponseStream;
+
+		/**
+		 * Push a progress part to this stream. Short-hand for
+		 * `push(new ChatResponseProgressPart(value))`.
+		*
+		* @param value A progress message
+		* @param task If provided, a task to run while the progress is displayed. When the Thenable resolves, the progress will be marked complete in the UI, and the progress message will be updated to the resolved string if one is specified.
+		* @returns This stream.
+		*/
+		progress(value: string, task?: (progress: Progress<ChatResponseWarningPart | ChatResponseReferencePart>) => Thenable<string | void>): void;
+
+		textEdit(target: Uri, edits: TextEdit | TextEdit[]): void;
+		markdownWithVulnerabilities(value: string | MarkdownString, vulnerabilities: ChatVulnerability[]): void;
+		detectedParticipant(participant: string, command?: ChatCommand): void;
+		push(part: ChatResponsePart | ChatResponseTextEditPart | ChatResponseDetectedParticipantPart | ChatResponseWarningPart | ChatResponseProgressPart2): void;
+
+		/**
+		 * Show an inline message in the chat view asking the user to confirm an action.
+		 * Multiple confirmations may be shown per response. The UI might show "Accept All" / "Reject All" actions.
+		 * @param title The title of the confirmation entry
+		 * @param message An extra message to display to the user
+		 * @param data An arbitrary JSON-stringifiable object that will be included in the ChatRequest when
+		 * the confirmation is accepted or rejected
+		 * TODO@API should this be MarkdownString?
+		 * TODO@API should actually be a more generic function that takes an array of buttons
+		 */
+		confirmation(title: string, message: string, data: any): void;
+
+		/**
+		 * Push a warning to this stream. Short-hand for
+		 * `push(new ChatResponseWarningPart(message))`.
+		 *
+		 * @param message A warning message
+		 * @returns This stream.
+		 */
+		warning(message: string | MarkdownString): void;
+
+		reference(value: Uri | Location | { variableName: string; value?: Uri | Location }, iconPath?: Uri | ThemeIcon | { light: Uri; dark: Uri }): void;
+
+		push(part: ExtendedChatResponsePart): void;
+	}
+
+	/**
+	 * Does this piggy-back on the existing ChatRequest, or is it a different type of request entirely?
+	 * Does it show up in history?
+	 */
+	export interface ChatRequest {
+		/**
+		 * The `data` for any confirmations that were accepted
+		 */
+		acceptedConfirmationData?: any[];
+
+		/**
+		 * The `data` for any confirmations that were rejected
+		 */
+		rejectedConfirmationData?: any[];
 	}
 
 	// TODO@API fit this into the stream
@@ -126,14 +151,17 @@ declare module 'vscode' {
 	}
 
 	export class ChatCompletionItem {
+		id: string;
 		label: string | CompletionItemLabel;
 		values: ChatVariableValue[];
+		fullName?: string;
+		icon?: ThemeIcon;
 		insertText?: string;
 		detail?: string;
 		documentation?: string | MarkdownString;
 		command?: Command;
 
-		constructor(label: string | CompletionItemLabel, values: ChatVariableValue[]);
+		constructor(id: string, label: string | CompletionItemLabel, values: ChatVariableValue[]);
 	}
 
 	export type ChatExtendedRequestHandler = (request: ChatRequest, context: ChatContext, response: ChatResponseStream, token: CancellationToken) => ProviderResult<ChatResult | void>;
@@ -144,7 +172,13 @@ declare module 'vscode' {
 		 */
 		export function createChatParticipant(id: string, handler: ChatExtendedRequestHandler): ChatParticipant;
 
-		export function createDynamicChatParticipant(id: string, name: string, description: string, handler: ChatExtendedRequestHandler): ChatParticipant;
+		/**
+		 * Current version of the proposal. Changes whenever backwards-incompatible changes are made.
+		 * If a new feature is added that doesn't break existing code, the version is not incremented. When the extension uses this new feature, it should set its engines.vscode version appropriately.
+		 * But if a change is made to an existing feature that would break existing code, the version should be incremented.
+		 * The chat extension should not activate if it doesn't support the current version.
+		 */
+		export const _version: 1 | number;
 	}
 
 	/*
@@ -209,51 +243,10 @@ declare module 'vscode' {
 		readonly action: ChatCopyAction | ChatInsertAction | ChatTerminalAction | ChatCommandAction | ChatFollowupAction | ChatBugReportAction | ChatEditorAction;
 	}
 
-	export interface ChatVariableValue {
+	export interface ChatPromptReference {
 		/**
-		 * An optional type tag for extensions to communicate the kind of the variable. An extension might use it to interpret the shape of `value`.
+		 * TODO Needed for now to drive the variableName-type reference, but probably both of these should go away in the future.
 		 */
-		kind?: string;
-	}
-
-	export interface ChatVariableResolverResponseStream {
-		/**
-		 * Push a progress part to this stream. Short-hand for
-		 * `push(new ChatResponseProgressPart(value))`.
-		 *
-		 * @param value
-		 * @returns This stream.
-		 */
-		progress(value: string): ChatVariableResolverResponseStream;
-
-		/**
-		 * Push a reference to this stream. Short-hand for
-		 * `push(new ChatResponseReferencePart(value))`.
-		 *
-		 * *Note* that the reference is not rendered inline with the response.
-		 *
-		 * @param value A uri or location
-		 * @returns This stream.
-		 */
-		reference(value: Uri | Location): ChatVariableResolverResponseStream;
-
-		/**
-		 * Pushes a part to this stream.
-		 *
-		 * @param part A response part, rendered or metadata
-		 */
-		push(part: ChatVariableResolverResponsePart): ChatVariableResolverResponseStream;
-	}
-
-	export type ChatVariableResolverResponsePart = ChatResponseProgressPart | ChatResponseReferencePart;
-
-	export interface ChatVariableResolver {
-		/**
-		 * A callback to resolve the value of a chat variable.
-		 * @param name The name of the variable.
-		 * @param context Contextual information about this chat request.
-		 * @param token A cancellation token.
-		 */
-		resolve2?(name: string, context: ChatVariableContext, stream: ChatVariableResolverResponseStream, token: CancellationToken): ProviderResult<ChatVariableValue[]>;
+		readonly name: string;
 	}
 }

package/vscode-dts/vscode.proposed.chatParticipantPrivate.d.ts

@@ -0,0 +1,76 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+declare module 'vscode' {
+
+	/**
+	 * The location at which the chat is happening.
+	 */
+	export enum ChatLocation {
+		/**
+		 * The chat panel
+		 */
+		Panel = 1,
+		/**
+		 * Terminal inline chat
+		 */
+		Terminal = 2,
+		/**
+		 * Notebook inline chat
+		 */
+		Notebook = 3,
+		/**
+		 * Code editor inline chat
+		 */
+		Editor = 4
+	}
+
+	export interface ChatRequest {
+		/**
+		 * The attempt number of the request. The first request has attempt number 0.
+		 */
+		readonly attempt: number;
+
+		/**
+		 * If automatic command detection is enabled.
+		 */
+		readonly enableCommandDetection: boolean;
+
+		/**
+		 * The location at which the chat is happening. This will always be one of the supported values
+		 */
+		readonly location: ChatLocation;
+	}
+
+	export interface ChatParticipant {
+		supportIssueReporting?: boolean;
+
+		/**
+		 * Temp, support references that are slow to resolve and should be tools rather than references.
+		 */
+		supportsSlowReferences?: boolean;
+	}
+
+	export interface ChatErrorDetails {
+		/**
+		 * If set to true, the message content is completely hidden. Only ChatErrorDetails#message will be shown.
+		 */
+		responseIsRedacted?: boolean;
+	}
+
+	export namespace chat {
+		export function createDynamicChatParticipant(id: string, dynamicProps: DynamicChatParticipantProps, handler: ChatExtendedRequestHandler): ChatParticipant;
+	}
+
+	/**
+	 * These don't get set on the ChatParticipant after creation, like other props, because they are typically defined in package.json and we want them at the time of creation.
+	 */
+	export interface DynamicChatParticipantProps {
+		name: string;
+		publisherName: string;
+		description?: string;
+		fullName?: string;
+	}
+}

package/vscode-dts/vscode.proposed.chatProvider.d.ts

@@ -19,22 +19,34 @@ declare module 'vscode' {
 
 		onDidReceiveLanguageModelResponse2?: Event<{ readonly extensionId: string; readonly participant?: string; readonly tokenCount?: number }>;
 
-		provideLanguageModelResponse2(messages: LanguageModelChatMessage[], options: { [name: string]: any }, extensionId: string, progress: Progress<ChatResponseFragment>, token: CancellationToken): Thenable<any>;
+		provideLanguageModelResponse(messages: LanguageModelChatMessage[], options: { [name: string]: any }, extensionId: string, progress: Progress<ChatResponseFragment>, token: CancellationToken): Thenable<any>;
 
 		provideTokenCount(text: string | LanguageModelChatMessage, token: CancellationToken): Thenable<number>;
 	}
 
 	export interface ChatResponseProviderMetadata {
+
+		readonly vendor: string;
+
+		/**
+		 * Human-readable name of the language model.
+		 */
+		readonly name: string;
+		/**
+		 * Opaque family-name of the language model. Values might be `gpt-3.5-turbo`, `gpt4`, `phi2`, or `llama`
+		 * but they are defined by extensions contributing languages and subject to change.
+		 */
+		readonly family: string;
+
 		/**
-		 * The name of the model that is used for this chat access. It is expected that the model name can
-		 * be used to lookup properties like token limits and ChatML support
+		 * Opaque version string of the model. This is defined by the extension contributing the language model
+		 * and subject to change while the identifier is stable.
 		 */
-		// TODO@API rename to model
-		name: string;
+		readonly version: string;
 
-		version: string;
+		readonly maxInputTokens: number;
 
-		tokens: number;
+		readonly maxOutputTokens: number;
 
 		/**
 		 * When present, this gates the use of `requestLanguageModelAccess` behind an authorization flow where
@@ -44,6 +56,11 @@ declare module 'vscode' {
 		auth?: true | { label: string };
 	}
 
+	export interface ChatResponseProviderMetadata {
+		// limit this provider to some extensions
+		extensions?: string[];
+	}
+
 	export namespace chat {
 
 		/**

package/vscode-dts/vscode.proposed.chatVariableResolver.d.ts

@@ -9,11 +9,25 @@ declare module 'vscode' {
 
 		/**
 		 * Register a variable which can be used in a chat request to any participant.
+		 * @param id A unique ID for the variable.
 		 * @param name The name of the variable, to be used in the chat input as `#name`.
-		 * @param description A description of the variable for the chat input suggest widget.
+		 * @param userDescription A description of the variable for the chat input suggest widget.
+		 * @param modelDescription A description of the variable for the model.
+		 * @param isSlow Temp, to limit access to '#codebase' which is not a 'reference' and will fit into a tools API later.
 		 * @param resolver Will be called to provide the chat variable's value when it is used.
+		 * @param fullName The full name of the variable when selecting context in the picker UI.
+		 * @param icon An icon to display when selecting context in the picker UI.
 		 */
-		export function registerChatVariableResolver(name: string, description: string, resolver: ChatVariableResolver): Disposable;
+		export function registerChatVariableResolver(id: string, name: string, userDescription: string, modelDescription: string | undefined, isSlow: boolean | undefined, resolver: ChatVariableResolver, fullName?: string, icon?: ThemeIcon): Disposable;
+
+		/**
+		 * Attaches a chat context with the specified name, value, and location.
+		 *
+		 * @param name - The name of the chat context.
+		 * @param value - The value of the chat context.
+		 * @param location - The location of the chat context.
+		 */
+		export function attachContext(name: string, value: string | Uri | Location | unknown, location: ChatLocation.Panel): void;
 	}
 
 	export interface ChatVariableValue {
@@ -52,5 +66,71 @@ declare module 'vscode' {
 		 * @param token A cancellation token.
 		 */
 		resolve(name: string, context: ChatVariableContext, token: CancellationToken): ProviderResult<ChatVariableValue[]>;
+
+		/**
+		 * A callback to resolve the value of a chat variable.
+		 * @param name The name of the variable.
+		 * @param context Contextual information about this chat request.
+		 * @param token A cancellation token.
+		*/
+		resolve2?(name: string, context: ChatVariableContext, stream: ChatVariableResolverResponseStream, token: CancellationToken): ProviderResult<ChatVariableValue[]>;
+	}
+
+
+	/**
+	 * The detail level of this chat variable value.
+	 */
+	export enum ChatVariableLevel {
+		Short = 1,
+		Medium = 2,
+		Full = 3
+	}
+
+	export interface ChatVariableValue {
+		/**
+		 * The detail level of this chat variable value. If possible, variable resolvers should try to offer shorter values that will consume fewer tokens in an LLM prompt.
+		 */
+		level: ChatVariableLevel;
+
+		/**
+		 * The variable's value, which can be included in an LLM prompt as-is, or the chat participant may decide to read the value and do something else with it.
+		 */
+		value: string | Uri;
+
+		/**
+		 * A description of this value, which could be provided to the LLM as a hint.
+		 */
+		description?: string;
+	}
+
+	export interface ChatVariableResolverResponseStream {
+		/**
+		 * Push a progress part to this stream. Short-hand for
+		 * `push(new ChatResponseProgressPart(value))`.
+		 *
+		 * @param value
+		 * @returns This stream.
+		 */
+		progress(value: string): ChatVariableResolverResponseStream;
+
+		/**
+		 * Push a reference to this stream. Short-hand for
+		 * `push(new ChatResponseReferencePart(value))`.
+		 *
+		 * *Note* that the reference is not rendered inline with the response.
+		 *
+		 * @param value A uri or location
+		 * @returns This stream.
+		 */
+		reference(value: Uri | Location): ChatVariableResolverResponseStream;
+
+		/**
+		 * Pushes a part to this stream.
+		 *
+		 * @param part A response part, rendered or metadata
+		 */
+		push(part: ChatVariableResolverResponsePart): ChatVariableResolverResponseStream;
 	}
+
+	export type ChatVariableResolverResponsePart = ChatResponseProgressPart | ChatResponseReferencePart;
 }

package/vscode-dts/vscode.proposed.defaultChatParticipant.d.ts

@@ -27,11 +27,6 @@ declare module 'vscode' {
 		 */
 		isDefault?: boolean;
 
-		/**
-		 * The full name of this participant.
-		 */
-		fullName?: string;
-
 		/**
 		 * When true, this participant is invoked when the user submits their query using ctrl/cmd+enter
 		 * TODO@API name

package/vscode-dts/vscode.proposed.editorHoverVerbosityLevel.d.ts

@@ -33,9 +33,9 @@ declare module 'vscode' {
 	export interface HoverContext {
 
 		/**
-		 * Whether to increase or decrease the hover's verbosity
+		 * The delta by which to increase/decrease the hover verbosity level
 		 */
-		readonly action?: HoverVerbosityAction;
+		readonly verbosityDelta?: number;
 
 		/**
 		 * The previous hover sent for the same position

package/vscode-dts/vscode.proposed.embeddings.d.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.
+ *--------------------------------------------------------------------------------------------*/
+
+declare module 'vscode' {
+
+	// https://github.com/microsoft/vscode/issues/212083
+
+	export interface Embedding {
+		readonly values: number[];
+	}
+
+	// TODO@API strictly not the right namespace...
+	export namespace lm {
+
+		export const embeddingModels: string[];
+
+		export const onDidChangeEmbeddingModels: Event<void>;
+
+		export function computeEmbeddings(embeddingsModel: string, input: string, token?: CancellationToken): Thenable<Embedding>;
+
+		export function computeEmbeddings(embeddingsModel: string, input: string[], token?: CancellationToken): Thenable<Embedding[]>;
+	}
+
+	export interface EmbeddingsProvider {
+		provideEmbeddings(input: string[], token: CancellationToken): ProviderResult<Embedding[]>;
+	}
+
+	export namespace lm {
+		export function registerEmbeddingsProvider(embeddingsModel: string, provider: EmbeddingsProvider): Disposable;
+	}
+}

package/vscode-dts/vscode.proposed.interactive.d.ts

@@ -5,117 +5,9 @@
 
 declare module 'vscode' {
 
-	export interface InteractiveEditorSlashCommand {
-		command: string;
-		detail?: string;
-		refer?: boolean;
-		/**
-		 * Whether the command should execute as soon
-		 * as it is entered. Defaults to `false`.
-		 */
-		executeImmediately?: boolean;
-		// kind: CompletionItemKind;
-	}
-
-	// todo@API make classes
-	export interface InteractiveEditorSession {
-		placeholder?: string;
-		input?: string;
-		slashCommands?: InteractiveEditorSlashCommand[];
-		wholeRange?: Range;
-		message?: string;
-	}
-
-	// todo@API make classes
-	export interface InteractiveEditorRequest {
-		prompt: string;
-		selection: Selection;
-		wholeRange: Range;
-		attempt: number;
-
-		/**
-		 * @deprecated, use previewDocument
-		 */
-		live: boolean;
-		previewDocument: TextDocument;
-		withIntentDetection: boolean;
-	}
-
-	// todo@API make classes
-	export interface InteractiveEditorResponse {
-		edits: TextEdit[] | WorkspaceEdit;
-		contents?: MarkdownString;
-		placeholder?: string;
-		wholeRange?: Range;
-	}
-
-	// todo@API make classes
-	export interface InteractiveEditorMessageResponse {
-		contents: MarkdownString;
-		placeholder?: string;
-		wholeRange?: Range;
-	}
-
-	export interface InteractiveEditorProgressItem {
-		message?: string;
-		edits?: TextEdit[];
-		editsShouldBeInstant?: boolean;
-		slashCommand?: InteractiveEditorSlashCommand;
-		content?: string | MarkdownString;
-	}
-
-	export enum InteractiveEditorResponseFeedbackKind {
-		Unhelpful = 0,
-		Helpful = 1,
-		Undone = 2,
-		Accepted = 3,
-		Bug = 4
-	}
-
-	export interface TextDocumentContext {
-		document: TextDocument;
-		selection: Selection;
-	}
-
-	export interface InteractiveEditorSessionProviderMetadata {
-		label?: string;
-		supportReportIssue?: boolean;
-	}
-
-	export interface InteractiveEditorReplyFollowup {
-		message: string;
-		tooltip?: string;
-		title?: string;
-	}
-
-	export interface InteractiveEditorCommandFollowup {
-		commandId: string;
-		args?: any[];
-		title: string;
-		when?: string;
-	}
-
-	export type InteractiveEditorFollowup = InteractiveEditorReplyFollowup | InteractiveEditorCommandFollowup;
-
-	export interface InteractiveEditorSessionProvider<S extends InteractiveEditorSession = InteractiveEditorSession, R extends InteractiveEditorResponse | InteractiveEditorMessageResponse = InteractiveEditorResponse | InteractiveEditorMessageResponse> {
-
-		// Create a session. The lifetime of this session is the duration of the editing session with the input mode widget.
-		prepareInteractiveEditorSession(context: TextDocumentContext, token: CancellationToken): ProviderResult<S>;
-
-		provideInteractiveEditorResponse(session: S, request: InteractiveEditorRequest, progress: Progress<InteractiveEditorProgressItem>, token: CancellationToken): ProviderResult<R>;
-
-		provideFollowups?(session: S, response: R, token: CancellationToken): ProviderResult<InteractiveEditorFollowup[]>;
-
-		// eslint-disable-next-line local/vscode-dts-provider-naming
-		handleInteractiveEditorResponseFeedback?(session: S, response: R, kind: InteractiveEditorResponseFeedbackKind): void;
-	}
-
 	export namespace interactive {
-		// current version of the proposal.
-		export const _version: 1 | number;
-
-		export function registerInteractiveEditorSessionProvider(provider: InteractiveEditorSessionProvider, metadata?: InteractiveEditorSessionProviderMetadata): Disposable;
-
+		// Can be deleted after another insiders
+		export const _version: number;
 		export function transferActiveChat(toWorkspace: Uri): void;
 	}
 }

package/vscode-dts/vscode.proposed.languageModelSystem.d.ts

@@ -0,0 +1,17 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+declare module 'vscode' {
+
+	// https://github.com/microsoft/vscode/issues/206265
+
+	// TODO@API don't have this dedicated type but as property, e.g anthropic doesn't have a system-role, see
+	// https://github.com/anthropics/anthropic-sdk-typescript/blob/c2da9604646ff103fbdbca016a9a9d49b03b387b/src/resources/messages.ts#L384
+	// So, we could have `LanguageModelChatRequestOptions#system` which would be more limiting but also more natural?
+
+	export enum LanguageModelChatMessageRole {
+		System = 3
+	}
+}

package/vscode-dts/vscode.proposed.resolvers.d.ts

@@ -141,7 +141,8 @@ declare module 'vscode' {
 	export enum CandidatePortSource {
 		None = 0,
 		Process = 1,
-		Output = 2
+		Output = 2,
+		Hybrid = 3
 	}
 
 	export type ResolverResult = (ResolvedAuthority | ManagedResolvedAuthority) & ResolvedOptions & TunnelInformation;