@codingame/monaco-vscode-api 20.4.1 → 21.0.0

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

@@ -3,142 +3,62 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-declare module 'vscode' {
-
-
-	// @API extension ship a d.ts files for their options
-
-	// @API the LanguageModelChatProvider2 is an alternative that combines a source, like ollama etc, with
-	// concrete models. The `provideLanguageModelChatData` would do the discovery and auth dances and later
-	// the model data is passed to the concrete function for making a requested or counting token
-
-
-	// TODO@API name scheme
-	export interface LanguageModelChatRequestHandleOptions {
-
-		// initiator
-		readonly extensionId: string;
+// version: 4
 
-		/**
-		 * A set of options that control the behavior of the language model. These options are specific to the language model
-		 * and need to be looked up in the respective documentation.
-		 */
-		readonly modelOptions: { [name: string]: any };
+declare module 'vscode' {
 
-		/**
-		 * An optional list of tools that are available to the language model. These could be registered tools available via
-		 * {@link lm.tools}, or private tools that are just implemented within the calling extension.
-		 *
-		 * If the LLM requests to call one of these tools, it will return a {@link LanguageModelToolCallPart} in
-		 * {@link LanguageModelChatResponse.stream}. It's the caller's responsibility to invoke the tool. If it's a tool
-		 * registered in {@link lm.tools}, that means calling {@link lm.invokeTool}.
-		 *
-		 * Then, the tool result can be provided to the LLM by creating an Assistant-type {@link LanguageModelChatMessage} with a
-		 * {@link LanguageModelToolCallPart}, followed by a User-type message with a {@link LanguageModelToolResultPart}.
-		 */
-		tools?: LanguageModelChatTool[];
+	/**
+	* The provider version of {@linkcode LanguageModelChatRequestOptions}
+	*/
+	export interface ProvideLanguageModelChatResponseOptions {
 
 		/**
-		 * 	The tool-selecting mode to use. {@link LanguageModelChatToolMode.Auto} by default.
+		 * What extension initiated the request to the language model
 		 */
-		toolMode?: LanguageModelChatToolMode;
+		readonly requestInitiator: string;
 	}
 
-	// TODO@API names: LanguageModelChatMetadata, LanguageModelChatItem
+	/**
+	 * All the information representing a single language model contributed by a {@linkcode LanguageModelChatProvider}.
+	 */
 	export interface LanguageModelChatInformation {
 
-		readonly id: 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;
-
-		/**
-		 * An optional, human-readable description of the language model.
-		 */
-		readonly description?: string;
-
-		/**
-		 * An optional, human-readable string representing the cost of using the language model.
-		 */
-		readonly cost?: string;
-
-		/**
-		 * 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.
-		 */
-		readonly version: string;
-
-		readonly maxInputTokens: number;
-
-		readonly maxOutputTokens: number;
-
 		/**
 		 * When present, this gates the use of `requestLanguageModelAccess` behind an authorization flow where
 		 * the user must approve of another extension accessing the models contributed by this extension.
 		 * Additionally, the extension can provide a label that will be shown in the UI.
+		 * A common example of a label is an account name that is signed in.
+		 *
 		 */
-		auth?: true | { label: string };
+		requiresAuthorization?: true | { label: string };
 
-		// TODO@API maybe an enum, LanguageModelChatProviderPickerAvailability?
-		// TODO@API isPreselected proposed
+		/**
+		 * Whether or not this will be selected by default in the model picker
+		 * NOT BEING FINALIZED
+		 */
 		readonly isDefault?: boolean;
 
-		// TODO@API nuke
+		/**
+		 * Whether or not the model will show up in the model picker immediately upon being made known via {@linkcode LanguageModelChatProvider.provideLanguageModelChatInformation}.
+		 * NOT BEING FINALIZED
+		 */
 		readonly isUserSelectable?: boolean;
 
-		readonly capabilities?: {
-
-			// TODO@API have mimeTypes that you support
-			readonly vision?: boolean;
-
-			// TODO@API should be `boolean | number` so extensions can express how many tools they support
-			readonly toolCalling?: boolean | number;
-
-			// TODO@API DO NOT SUPPORT THIS
-			// readonly agentMode?: boolean;
-
-			// TODO@API support prompt TSX style messages, MAYBE leave it out for now
-			readonly promptTsx?: boolean;
-		};
-
 		/**
 		 * Optional category to group models by in the model picker.
 		 * The lower the order, the higher the category appears in the list.
 		 * Has no effect if `isUserSelectable` is `false`.
-		 * If not specified, the model will appear in the "Other Models" category.
+		 *
+		 * WONT BE FINALIZED
 		 */
 		readonly category?: { label: string; order: number };
-	}
-
-	export interface LanguageModelChatProvider2<T extends LanguageModelChatInformation = LanguageModelChatInformation> {
-
-		// signals a change from the provider to the editor so that prepareLanguageModelChat is called again
-		onDidChange?: Event<void>;
 
-		// NOT cacheable (between reloads)
-		prepareLanguageModelChat(options: { silent: boolean }, token: CancellationToken): ProviderResult<T[]>;
-
-		provideLanguageModelChatResponse(model: T, messages: Array<LanguageModelChatMessage | LanguageModelChatMessage2>, options: LanguageModelChatRequestHandleOptions, progress: Progress<ChatResponseFragment2>, token: CancellationToken): Thenable<any>;
-
-		provideTokenCount(model: T, text: string | LanguageModelChatMessage | LanguageModelChatMessage2, token: CancellationToken): Thenable<number>;
-	}
-
-	export namespace lm {
-
-		export function registerChatModelProvider(vendor: string, provider: LanguageModelChatProvider2): Disposable;
+		readonly statusIcon?: ThemeIcon;
 	}
 
+	export type LanguageModelResponsePart2 = LanguageModelResponsePart | LanguageModelDataPart | LanguageModelThinkingPart;
 
-
-	export interface ChatResponseFragment2 {
-		index: number;
-		part: LanguageModelTextPart | LanguageModelToolCallPart;
+	export interface LanguageModelChatProvider<T extends LanguageModelChatInformation = LanguageModelChatInformation> {
+		provideLanguageModelChatResponse(model: T, messages: readonly LanguageModelChatRequestMessage[], options: ProvideLanguageModelChatResponseOptions, progress: Progress<LanguageModelResponsePart2>, token: CancellationToken): Thenable<void>;
 	}
 }

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

@@ -4,6 +4,26 @@
  *--------------------------------------------------------------------------------------------*/
 
 declare module 'vscode' {
+	/**
+	 * Represents the status of a chat session.
+	 */
+	export enum ChatSessionStatus {
+		/**
+		 * The chat session failed to complete.
+		 */
+		Failed = 0,
+
+		/**
+		 * The chat session completed successfully.
+		 */
+		Completed = 1,
+
+		/**
+		 * The chat session is currently in progress.
+		 */
+		InProgress = 2
+	}
+
 	/**
 	 * Provides a list of information about chat sessions.
 	 */
@@ -13,16 +33,34 @@ declare module 'vscode' {
 		 */
 		readonly onDidChangeChatSessionItems: Event<void>;
 
-		// /**
-		//  * Create a new chat session item
-		//  */
-		// provideNewChatSessionItem(context: {
-		// 	// This interface should be extracted
-		// 	readonly triggerChat?: {
-		// 		readonly prompt: string;
-		// 		readonly history: ReadonlyArray<ChatRequestTurn | ChatResponseTurn>;
-		// 	};
-		// }, token: CancellationToken): Thenable<ChatSessionItem> | ChatSessionItem;
+		/**
+		 * Creates a new chat session.
+		 *
+		 * @param options Options for the new session including an optional initial prompt and history
+		 * @param token A cancellation token
+		 * @returns Metadata for the chat session
+		 */
+		provideNewChatSessionItem?(options: {
+			/**
+			 * The chat request that initiated the session creation
+			 */
+			readonly request: ChatRequest;
+
+			/**
+			 * Initial prompt to initiate the session
+			 */
+			readonly prompt?: string;
+
+			/**
+			 * History to initialize the session with
+			 */
+			readonly history?: ReadonlyArray<ChatRequestTurn | ChatResponseTurn>;
+
+			/**
+			 * Additional metadata to use for session creation
+			 */
+			metadata?: any;
+		}, token: CancellationToken): ProviderResult<ChatSessionItem>;
 
 		/**
 		 * Provides a list of chat sessions.
@@ -46,10 +84,53 @@ declare module 'vscode' {
 		 * An icon for the participant shown in UI.
 		 */
 		iconPath?: IconPath;
+
+		/**
+		 * An optional description that provides additional context about the chat session.
+		 */
+		description?: string | MarkdownString;
+
+		/**
+		 * An optional status indicating the current state of the session.
+		 */
+		status?: ChatSessionStatus;
+
+		/**
+		 * The tooltip text when you hover over this item.
+		 */
+		tooltip?: string | MarkdownString;
+
+		/**
+		 * The times at which session started and ended
+		 */
+		timing?: {
+			/**
+			 * Session start timestamp in milliseconds elapsed since January 1, 1970 00:00:00 UTC.
+			 */
+			startTime: number;
+			/**
+			 * Session end timestamp in milliseconds elapsed since January 1, 1970 00:00:00 UTC.
+			 */
+			endTime?: number;
+		};
+
+		/**
+		 * Statistics about the chat session.
+		 */
+		statistics?: {
+			/**
+			 * Number of insertions made during the session.
+			 */
+			insertions: number;
+
+			/**
+			 * Number of deletions made during the session.
+			 */
+			deletions: number;
+		};
 	}
 
 	export interface ChatSession {
-
 		/**
 		 * The full history of the session
 		 *
@@ -74,6 +155,7 @@ declare module 'vscode' {
 		 * If not set, then the session will be considered read-only and no requests can be made.
 		 */
 		// TODO: Should we introduce our own type for `ChatRequestHandler` since not all field apply to chat sessions?
+		// TODO: Revisit this to align with code.
 		readonly requestHandler: ChatRequestHandler | undefined;
 	}
 
@@ -108,7 +190,14 @@ declare module 'vscode' {
 		 *
 		 * @returns A disposable that unregisters the provider when disposed.
 		 */
-		export function registerChatSessionContentProvider(chatSessionType: string, provider: ChatSessionContentProvider): Disposable;
+		export function registerChatSessionContentProvider(chatSessionType: string, provider: ChatSessionContentProvider, capabilities?: ChatSessionCapabilities): Disposable;
+	}
+
+	export interface ChatSessionCapabilities {
+		/**
+		 * Whether sessions can be interrupted and resumed without side-effects.
+		 */
+		supportsInterruptions?: boolean;
 	}
 
 	export interface ChatSessionShowOptions {

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

@@ -0,0 +1,6 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+// empty placeholder declaration for the `secondarySidebar`-contribution point

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

@@ -7,6 +7,7 @@ import "./vscode.proposed.authIssuers.d.ts"
 import "./vscode.proposed.authLearnMore.d.ts"
 import "./vscode.proposed.authProviderSpecific.d.ts"
 import "./vscode.proposed.authSession.d.ts"
+import "./vscode.proposed.authenticationChallenges.d.ts"
 import "./vscode.proposed.canonicalUriProvider.d.ts"
 import "./vscode.proposed.chatEditing.d.ts"
 import "./vscode.proposed.chatOutputRenderer.d.ts"
@@ -42,6 +43,7 @@ import "./vscode.proposed.contribMergeEditorMenus.d.ts"
 import "./vscode.proposed.contribMultiDiffEditorMenus.d.ts"
 import "./vscode.proposed.contribNotebookStaticPreloads.d.ts"
 import "./vscode.proposed.contribRemoteHelp.d.ts"
+import "./vscode.proposed.contribSecondarySidebar.d.ts"
 import "./vscode.proposed.contribShareMenu.d.ts"
 import "./vscode.proposed.contribSourceControlHistoryItemMenu.d.ts"
 import "./vscode.proposed.contribSourceControlHistoryTitleMenu.d.ts"
@@ -79,6 +81,7 @@ import "./vscode.proposed.ipc.d.ts"
 import "./vscode.proposed.languageModelCapabilities.d.ts"
 import "./vscode.proposed.languageModelDataPart.d.ts"
 import "./vscode.proposed.languageModelSystem.d.ts"
+import "./vscode.proposed.languageModelThinkingPart.d.ts"
 import "./vscode.proposed.languageModelToolResultAudience.d.ts"
 import "./vscode.proposed.languageStatusText.d.ts"
 import "./vscode.proposed.mappedEditsProvider.d.ts"

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

@@ -39,11 +39,6 @@ declare module 'vscode' {
 		 */
 		helpTextPrefix?: string | MarkdownString;
 
-		/**
-		 * A string that will be added before the listing of chat variables in `/help`.
-		 */
-		helpTextVariablesPrefix?: string | MarkdownString;
-
 		/**
 		 * A string that will be appended after the listing of chat participants in `/help`.
 		 */

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

@@ -21,6 +21,24 @@ declare module 'vscode' {
 		 * @return A {@link Disposable} that unregisters this provider when being disposed.
 		 */
 		export function registerInlineCompletionItemProvider(selector: DocumentSelector, provider: InlineCompletionItemProvider, metadata: InlineCompletionItemProviderMetadata): Disposable;
+
+		/**
+		 * temporary: to be removed
+		 */
+		export const inlineCompletionsUnificationState: InlineCompletionsUnificationState;
+		/**
+		 * temporary: to be removed
+		 */
+		export const onDidChangeCompletionsUnificationState: Event<void>;
+	}
+
+	/**
+	 * temporary: to be removed
+	 */
+	export interface InlineCompletionsUnificationState {
+		codeUnification: boolean;
+		modelUnification: boolean;
+		expAssignments: string[];
 	}
 
 	export interface InlineCompletionItem {
@@ -46,10 +64,19 @@ declare module 'vscode' {
 		action?: Command;
 
 		displayLocation?: InlineCompletionDisplayLocation;
+
+		/** Used for telemetry. Can be an arbitrary string. */
+		correlationId?: string;
+	}
+
+	export enum InlineCompletionDisplayLocationKind {
+		Code = 1,
+		Label = 2
 	}
 
 	export interface InlineCompletionDisplayLocation {
 		range: Range;
+		kind: InlineCompletionDisplayLocationKind;
 		label: string;
 	}
 
@@ -72,6 +99,8 @@ declare module 'vscode' {
 		debounceDelayMs?: number;
 
 		displayName?: string;
+
+		excludes?: string[];
 	}
 
 	export interface InlineCompletionItemProvider {
@@ -156,6 +185,8 @@ declare module 'vscode' {
 		readonly requestUuid: string;
 
 		readonly requestIssuedDateTime: number;
+
+		readonly earliestShownDateTime: number;
 	}
 
 	export interface PartialAcceptInfo {

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

@@ -42,7 +42,7 @@ declare module 'vscode' {
 		 * A string or heterogeneous array of things that a message can contain as content. Some parts may be message-type
 		 * specific for some models.
 		 */
-		content: Array<LanguageModelTextPart | LanguageModelToolResultPart2 | LanguageModelToolCallPart | LanguageModelDataPart>;
+		content: Array<LanguageModelTextPart | LanguageModelToolResultPart2 | LanguageModelToolCallPart | LanguageModelDataPart | LanguageModelThinkingPart>;
 
 		/**
 		 * The optional name of a user for this message.
@@ -56,7 +56,7 @@ declare module 'vscode' {
 		 * @param content The content of the message.
 		 * @param name The optional name of a user for the message.
 		 */
-		constructor(role: LanguageModelChatMessageRole, content: string | Array<LanguageModelTextPart | LanguageModelToolResultPart2 | LanguageModelToolCallPart | LanguageModelDataPart>, name?: string);
+		constructor(role: LanguageModelChatMessageRole, content: string | Array<LanguageModelTextPart | LanguageModelToolResultPart2 | LanguageModelToolCallPart | LanguageModelDataPart | LanguageModelThinkingPart>, name?: string);
 	}
 
 	/**

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

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+// version: 1
+
+declare module 'vscode' {
+
+	/**
+	 * A language model response part containing thinking/reasoning content.
+	 * Thinking tokens represent the model's internal reasoning process that
+	 * typically streams before the final response.
+	 */
+	export class LanguageModelThinkingPart {
+		/**
+		 * The thinking/reasoning text content.
+		 */
+		value: string | string[];
+
+		/**
+		 * Optional unique identifier for this thinking sequence.
+		 * This ID is typically provided at the end of the thinking stream
+		 * and can be used for retrieval or reference purposes.
+		 */
+		id?: string;
+
+		/**
+		 * Optional metadata associated with this thinking sequence.
+		 */
+		metadata?: { readonly [key: string]: any };
+
+		/**
+		 * Construct a thinking part with the given content.
+		 * @param value The thinking text content.
+		 * @param id Optional unique identifier for this thinking sequence.
+		 * @param metadata Optional metadata associated with this thinking sequence.
+		 */
+		constructor(value: string | string[], id?: string, metadata?: { readonly [key: string]: any });
+	}
+
+	export interface LanguageModelChatResponse {
+		/**
+		 * An async iterable that is a stream of text, thinking, and tool-call parts forming the overall response.
+		 * This includes {@link LanguageModelThinkingPart} which represents the model's internal reasoning process.
+		 */
+		stream: AsyncIterable<LanguageModelTextPart | LanguageModelThinkingPart | LanguageModelToolCallPart | unknown>;
+	}
+}

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

@@ -5,21 +5,32 @@
 
 declare module 'vscode' {
 
-	export enum ToolResultAudience {
+	export enum LanguageModelPartAudience {
+		/**
+		 * The part should be shown to the language model.
+		 */
 		Assistant = 0,
+		/**
+		 * The part should be shown to the user.
+		 */
 		User = 1,
+		/**
+		 * The part should should be retained for internal bookkeeping within
+		 * extensions.
+		 */
+		Extension = 2,
 	}
 
 	/**
 	 * A language model response part containing a piece of text, returned from a {@link LanguageModelChatResponse}.
 	 */
 	export class LanguageModelTextPart2 extends LanguageModelTextPart {
-		audience: ToolResultAudience[] | undefined;
-		constructor(value: string, audience?: ToolResultAudience[]);
+		audience: LanguageModelPartAudience[] | undefined;
+		constructor(value: string, audience?: LanguageModelPartAudience[]);
 	}
 
 	export class LanguageModelDataPart2 extends LanguageModelDataPart {
-		audience: ToolResultAudience[] | undefined;
-		constructor(data: Uint8Array, mimeType: string, audience?: ToolResultAudience[]);
+		audience: LanguageModelPartAudience[] | undefined;
+		constructor(data: Uint8Array, mimeType: string, audience?: LanguageModelPartAudience[]);
 	}
 }

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

@@ -68,6 +68,13 @@ declare module 'vscode' {
 		Flag = 7,
 		SymbolicLinkFile = 8,
 		SymbolicLinkFolder = 9,
+		Commit = 10,
+		Branch = 11,
+		Tag = 12,
+		Stash = 13,
+		Remote = 14,
+		PullRequest = 15,
+		PullRequestDone = 16,
 	}
 
 	export interface TerminalCompletionContext {

package/workers/editor.worker.d.ts

@@ -1,7 +1,4 @@
 import type { IWorkerContext } from "../vscode/src/vs/editor/common/services/editorWebWorker.js";
-/**
- * Make the `initialize` method backward compatible, until the monaco standalone workers are updated
- */
 type CreateFunction<D, R extends object = object> = (ctx: IWorkerContext<object>, data: D) => R;
-export declare function initialize<D, R extends object>(createFn: CreateFunction<D, R>): void;
-export {};
+declare function initialize<D, R extends object>(createFn: CreateFunction<D, R>): void;
+export { initialize };

package/workers/editor.worker.js

@@ -2,26 +2,24 @@
 import '../vscode/src/vs/editor/common/services/editorWebWorkerMain.js';
 import { start } from '../vscode/src/vs/editor/editor.worker.start.js';
 
+let initialized = false;
+function isWorkerInitialized() {
+    return initialized;
+}
 function initialize(createFn) {
-    start((context) => {
-        let requestHandler;
-        return new Proxy({}, {
-            get(_target, propKey) {
-                if (propKey === '$initialize') {
-                    return async (data) => {
-                        if (!requestHandler) {
-                            requestHandler = createFn(context, data);
-                        }
-                    };
-                }
-                const value = requestHandler?.[propKey];
-                if (typeof value === 'function') {
-                    return value.bind(requestHandler);
-                }
-                return value;
-            }
+    initialized = true;
+    self.onmessage = (m) => {
+        start((ctx) => {
+            return createFn(ctx, m.data);
         });
-    });
+    };
 }
+self.onmessage = () => {
+    if (!isWorkerInitialized()) {
+        start(() => {
+            return {};
+        });
+    }
+};
 
 export { initialize };