@codingame/monaco-vscode-api 1.83.14 → 1.83.15-next.0

package/vscode/src/vs/workbench/services/extensions/common/extensionDescriptionRegistry.d.ts

@@ -1,11 +1,5 @@
-import { Event } from '../../../../base/common/event.js';
-import { ExtensionIdentifier, IExtensionDescription } from '../../../../platform/extensions/common/extensions.js';
+import { IExtensionDescription, ExtensionIdentifier } from '../../../../platform/extensions/common/extensions.js';
 
-declare class DeltaExtensionsResult {
-    readonly versionId: number;
-    readonly removedDueToLooping: IExtensionDescription[];
-    constructor(versionId: number, removedDueToLooping: IExtensionDescription[]);
-}
 interface IReadOnlyExtensionDescriptionRegistry {
     containsActivationEvent(activationEvent: string): boolean;
     containsExtension(extensionId: ExtensionIdentifier): boolean;
@@ -15,39 +9,10 @@ interface IReadOnlyExtensionDescriptionRegistry {
     getExtensionDescriptionByUUID(uuid: string): IExtensionDescription | undefined;
     getExtensionDescriptionByIdOrUUID(extensionId: ExtensionIdentifier | string, uuid: string | undefined): IExtensionDescription | undefined;
 }
-declare class ExtensionDescriptionRegistry implements IReadOnlyExtensionDescriptionRegistry {
-    private readonly _activationEventsReader;
-    static isHostExtension(extensionId: ExtensionIdentifier | string, myRegistry: ExtensionDescriptionRegistry, globalRegistry: ExtensionDescriptionRegistry): boolean;
-    private readonly _onDidChange;
-    readonly onDidChange: Event<void>;
-    private _versionId;
-    private _extensionDescriptions;
-    private _extensionsMap;
-    private _extensionsArr;
-    private _activationMap;
-    constructor(_activationEventsReader: IActivationEventsReader, extensionDescriptions: IExtensionDescription[]);
-    private _initialize;
-    set(extensionDescriptions: IExtensionDescription[]): {
-        versionId: number;
-    };
-    deltaExtensions(toAdd: IExtensionDescription[], toRemove: ExtensionIdentifier[]): DeltaExtensionsResult;
-    private static _findLoopingExtensions;
-    containsActivationEvent(activationEvent: string): boolean;
-    containsExtension(extensionId: ExtensionIdentifier): boolean;
-    getExtensionDescriptionsForActivationEvent(activationEvent: string): IExtensionDescription[];
-    getAllExtensionDescriptions(): IExtensionDescription[];
-    getSnapshot(): ExtensionDescriptionRegistrySnapshot;
-    getExtensionDescription(extensionId: ExtensionIdentifier | string): IExtensionDescription | undefined;
-    getExtensionDescriptionByUUID(uuid: string): IExtensionDescription | undefined;
-    getExtensionDescriptionByIdOrUUID(extensionId: ExtensionIdentifier | string, uuid: string | undefined): IExtensionDescription | undefined;
-}
 declare class ExtensionDescriptionRegistrySnapshot {
     readonly versionId: number;
     readonly extensions: readonly IExtensionDescription[];
     constructor(versionId: number, extensions: readonly IExtensionDescription[]);
 }
-interface IActivationEventsReader {
-    readActivationEvents(extensionDescription: IExtensionDescription): string[] | undefined;
-}
 
-export { DeltaExtensionsResult, ExtensionDescriptionRegistry, ExtensionDescriptionRegistrySnapshot, type IActivationEventsReader, type IReadOnlyExtensionDescriptionRegistry };
+export { ExtensionDescriptionRegistrySnapshot, type IReadOnlyExtensionDescriptionRegistry };

package/vscode/src/vs/workbench/services/extensions/common/extensionHostProtocol.d.ts

@@ -1,7 +1,4 @@
-import { URI, UriDto, UriComponents } from '../../../../base/common/uri.js';
-import { ExtensionIdentifier, IExtensionDescription } from '../../../../platform/extensions/common/extensions.js';
-import { LogLevel, ILoggerResource } from '../../../../platform/log/common/log.js';
-import { IRemoteConnectionData } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
+import { IExtensionDescription, ExtensionIdentifier } from '../../../../platform/extensions/common/extensions.js';
 
 interface IExtensionDescriptionSnapshot {
     readonly versionId: number;
@@ -21,73 +18,5 @@ interface IExtensionDescriptionDelta {
     readonly myToRemove: ExtensionIdentifier[];
     readonly myToAdd: ExtensionIdentifier[];
 }
-interface IExtensionHostInitData {
-    version: string;
-    quality: string | undefined;
-    commit?: string;
-    /**
-     * When set to `0`, no polling for the parent process still running will happen.
-     */
-    parentPid: number | 0;
-    environment: IEnvironment;
-    workspace?: IStaticWorkspaceData | null;
-    extensions: IExtensionDescriptionSnapshot;
-    nlsBaseUrl?: URI;
-    telemetryInfo: {
-        readonly sessionId: string;
-        readonly machineId: string;
-        readonly firstSessionDate: string;
-        readonly msftInternal?: boolean;
-    };
-    logLevel: LogLevel;
-    loggers: UriDto<ILoggerResource>[];
-    logsLocation: URI;
-    autoStart: boolean;
-    remote: {
-        isRemote: boolean;
-        authority: string | undefined;
-        connectionData: IRemoteConnectionData | null;
-    };
-    consoleForward: {
-        includeStack: boolean;
-        logNative: boolean;
-    };
-    uiKind: UIKind;
-    messagePorts?: ReadonlyMap<string, MessagePortLike>;
-}
-interface IEnvironment {
-    isExtensionDevelopmentDebug: boolean;
-    appName: string;
-    appHost: string;
-    appRoot?: URI;
-    appLanguage: string;
-    extensionTelemetryLogResource: URI;
-    isExtensionTelemetryLoggingOnly: boolean;
-    appUriScheme: string;
-    extensionDevelopmentLocationURI?: URI[];
-    extensionTestsLocationURI?: URI;
-    globalStorageHome: URI;
-    workspaceStorageHome: URI;
-    useHostProxy?: boolean;
-    skipWorkspaceStorageLock?: boolean;
-    extensionLogLevel?: [string, string][];
-}
-interface IStaticWorkspaceData {
-    id: string;
-    name: string;
-    transient?: boolean;
-    configuration?: UriComponents | null;
-    isUntitled?: boolean | null;
-}
-interface MessagePortLike {
-    postMessage(message: any, transfer?: any[]): void;
-    addEventListener(type: 'message', listener: (e: any) => any): void;
-    removeEventListener(type: 'message', listener: (e: any) => any): void;
-    start(): void;
-}
-declare enum UIKind {
-    Desktop = 1,
-    Web = 2
-}
 
-export { type IEnvironment, type IExtensionDescriptionDelta, type IExtensionDescriptionSnapshot, type IExtensionHostInitData, type IStaticWorkspaceData, type MessagePortLike, UIKind };
+export type { IExtensionDescriptionDelta, IExtensionDescriptionSnapshot };

package/vscode/src/vs/workbench/services/extensions/common/extensions.d.ts

@@ -22,10 +22,6 @@ interface IExtensionsStatus {
     runtimeErrors: Error[];
     runningLocation: ExtensionRunningLocation | null;
 }
-declare class MissingExtensionDependency {
-    readonly dependency: string;
-    constructor(dependency: string);
-}
 declare const enum ExtensionHostStartup {
     /**
      * The extension host should be launched immediately and doesn't require a `$startExtensionHost` call.
@@ -237,4 +233,4 @@ interface IExtensionService {
     }): Promise<void>;
 }
 
-export { ActivationKind, ActivationTimes, type ExtensionActivationReason, ExtensionHostExtensions, ExtensionHostStartup, ExtensionPointContribution, type IExtensionHost, IExtensionService, type IExtensionsStatus, type IMessage, type IResponsiveStateChangeEvent, type IWillActivateEvent, MissingExtensionDependency, type WillStopExtensionHostsEvent };
+export { ActivationKind, ActivationTimes, type ExtensionActivationReason, ExtensionHostExtensions, ExtensionHostStartup, ExtensionPointContribution, type IExtensionHost, IExtensionService, type IExtensionsStatus, type IMessage, type IResponsiveStateChangeEvent, type IWillActivateEvent, type WillStopExtensionHostsEvent };

package/vscode/src/vs/workbench/services/themes/common/iconExtensionPoint.js

@@ -0,0 +1,174 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { ExtensionsRegistry } from '../../extensions/common/extensionsRegistry.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
+import { extname, posix } from 'monaco-editor/esm/vs/base/common/path.js';
+const iconRegistry = ( Registry.as(Extensions.IconContribution));
+const iconReferenceSchema = iconRegistry.getIconReferenceSchema();
+const iconIdPattern = `^${ThemeIcon.iconNameSegment}(-${ThemeIcon.iconNameSegment})+$`;
+const iconConfigurationExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'icons',
+    jsonSchema: {
+        description: ( nls.localizeWithPath(
+            'vs/workbench/services/themes/common/iconExtensionPoint',
+            'contributes.icons',
+            'Contributes extension defined themable icons'
+        )),
+        type: 'object',
+        propertyNames: {
+            pattern: iconIdPattern,
+            description: ( nls.localizeWithPath(
+                'vs/workbench/services/themes/common/iconExtensionPoint',
+                'contributes.icon.id',
+                'The identifier of the themable icon'
+            )),
+            patternErrorMessage: ( nls.localizeWithPath(
+                'vs/workbench/services/themes/common/iconExtensionPoint',
+                'contributes.icon.id.format',
+                'Identifiers can only contain letters, digits and minuses and need to consist of at least two segments in the form `component-iconname`.'
+            )),
+        },
+        additionalProperties: {
+            type: 'object',
+            properties: {
+                description: {
+                    type: 'string',
+                    description: ( nls.localizeWithPath(
+                        'vs/workbench/services/themes/common/iconExtensionPoint',
+                        'contributes.icon.description',
+                        'The description of the themable icon'
+                    )),
+                },
+                default: {
+                    anyOf: [
+                        iconReferenceSchema,
+                        {
+                            type: 'object',
+                            properties: {
+                                fontPath: {
+                                    description: ( nls.localizeWithPath(
+                                        'vs/workbench/services/themes/common/iconExtensionPoint',
+                                        'contributes.icon.default.fontPath',
+                                        'The path of the icon font that defines the icon.'
+                                    )),
+                                    type: 'string'
+                                },
+                                fontCharacter: {
+                                    description: ( nls.localizeWithPath(
+                                        'vs/workbench/services/themes/common/iconExtensionPoint',
+                                        'contributes.icon.default.fontCharacter',
+                                        'The character for the icon in the icon font.'
+                                    )),
+                                    type: 'string'
+                                }
+                            },
+                            required: ['fontPath', 'fontCharacter'],
+                            defaultSnippets: [{ body: { fontPath: '${1:myiconfont.woff}', fontCharacter: '${2:\\\\E001}' } }]
+                        }
+                    ],
+                    description: ( nls.localizeWithPath(
+                        'vs/workbench/services/themes/common/iconExtensionPoint',
+                        'contributes.icon.default',
+                        'The default of the icon. Either a reference to an extisting ThemeIcon or an icon in an icon font.'
+                    )),
+                }
+            },
+            required: ['description', 'default'],
+            defaultSnippets: [{ body: { description: '${1:my icon}', default: { fontPath: '${2:myiconfont.woff}', fontCharacter: '${3:\\\\E001}' } } }]
+        },
+        defaultSnippets: [{ body: { '${1:my-icon-id}': { description: '${2:my icon}', default: { fontPath: '${3:myiconfont.woff}', fontCharacter: '${4:\\\\E001}' } } } }]
+    }
+}));
+class IconExtensionPoint {
+    constructor() {
+        iconConfigurationExtPoint.setHandler((extensions, delta) => {
+            for (const extension of delta.added) {
+                const extensionValue = extension.value;
+                const collector = extension.collector;
+                if (!extensionValue || typeof extensionValue !== 'object') {
+                    collector.error(( nls.localizeWithPath(
+                        'vs/workbench/services/themes/common/iconExtensionPoint',
+                        'invalid.icons.configuration',
+                        "'configuration.icons' must be an object with the icon names as properties."
+                    )));
+                    return;
+                }
+                for (const id in extensionValue) {
+                    if (!id.match(iconIdPattern)) {
+                        collector.error(( nls.localizeWithPath(
+                            'vs/workbench/services/themes/common/iconExtensionPoint',
+                            'invalid.icons.id.format',
+                            "'configuration.icons' keys represent the icon id and can only contain letter, digits and minuses. They need to consist of at least two segments in the form `component-iconname`."
+                        )));
+                        return;
+                    }
+                    const iconContribution = extensionValue[id];
+                    if (typeof iconContribution.description !== 'string' || iconContribution.description.length === 0) {
+                        collector.error(( nls.localizeWithPath(
+                            'vs/workbench/services/themes/common/iconExtensionPoint',
+                            'invalid.icons.description',
+                            "'configuration.icons.description' must be defined and can not be empty"
+                        )));
+                        return;
+                    }
+                    const defaultIcon = iconContribution.default;
+                    if (typeof defaultIcon === 'string') {
+                        iconRegistry.registerIcon(id, { id: defaultIcon }, iconContribution.description);
+                    }
+                    else if (typeof defaultIcon === 'object' && typeof defaultIcon.fontPath === 'string' && typeof defaultIcon.fontCharacter === 'string') {
+                        const format = extname(defaultIcon.fontPath).substring(1);
+                        if (['woff', 'woff2', 'ttf'].indexOf(format) === -1) {
+                            collector.warn(( nls.localizeWithPath(
+                                'vs/workbench/services/themes/common/iconExtensionPoint',
+                                'invalid.icons.default.fontPath.extension',
+                                "Expected `contributes.icons.default.fontPath` to have file extension 'woff', woff2' or 'ttf', is '{0}'.",
+                                format
+                            )));
+                            return;
+                        }
+                        const extensionLocation = extension.description.extensionLocation;
+                        const iconFontLocation = resources.joinPath(extensionLocation, defaultIcon.fontPath);
+                        if (!resources.isEqualOrParent(iconFontLocation, extensionLocation)) {
+                            collector.warn(( nls.localizeWithPath(
+                                'vs/workbench/services/themes/common/iconExtensionPoint',
+                                'invalid.icons.default.fontPath.path',
+                                "Expected `contributes.icons.default.fontPath` ({0}) to be included inside extension's folder ({0}).",
+                                iconFontLocation.path,
+                                extensionLocation.path
+                            )));
+                            return;
+                        }
+                        const fontId = getFontId(extension.description, defaultIcon.fontPath);
+                        const definition = iconRegistry.registerIconFont(fontId, { src: [{ location: iconFontLocation, format }] });
+                        iconRegistry.registerIcon(id, {
+                            fontCharacter: defaultIcon.fontCharacter,
+                            font: {
+                                id: fontId,
+                                definition
+                            }
+                        }, iconContribution.description);
+                    }
+                    else {
+                        collector.error(( nls.localizeWithPath(
+                            'vs/workbench/services/themes/common/iconExtensionPoint',
+                            'invalid.icons.default',
+                            "'configuration.icons.default' must be either a reference to the id of an other theme icon (string) or a icon definition (object) with properties `fontPath` and `fontCharacter`."
+                        )));
+                    }
+                }
+            }
+            for (const extension of delta.removed) {
+                const extensionValue = extension.value;
+                for (const id in extensionValue) {
+                    iconRegistry.deregisterIcon(id);
+                }
+            }
+        });
+    }
+}
+function getFontId(description, fontPath) {
+    return posix.join(description.identifier.value, fontPath);
+}
+export { IconExtensionPoint };

package/vscode-dts/vscode.proposed.aiRelatedInformation.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.
+ *--------------------------------------------------------------------------------------------*/
+
+declare module 'vscode' {
+
+	// https://github.com/microsoft/vscode/issues/190909
+
+	export enum RelatedInformationType {
+		SymbolInformation = 1,
+		CommandInformation = 2,
+		SearchInformation = 3,
+		SettingInformation = 4
+	}
+
+	interface RelatedInformationBaseResult {
+		type: RelatedInformationType;
+		weight: number;
+	}
+
+	// TODO: Symbols and Search
+
+	export interface CommandInformationResult extends RelatedInformationBaseResult {
+		type: RelatedInformationType.CommandInformation;
+		command: string;
+	}
+
+	export interface SettingInformationResult extends RelatedInformationBaseResult {
+		type: RelatedInformationType.SettingInformation;
+		setting: string;
+	}
+
+	export type RelatedInformationResult = CommandInformationResult | SettingInformationResult;
+
+	export interface RelatedInformationProvider {
+		provideRelatedInformation(query: string, token: CancellationToken): ProviderResult<RelatedInformationResult[]>;
+	}
+
+	export interface EmbeddingVectorProvider {
+		provideEmbeddingVector(strings: string[], token: CancellationToken): ProviderResult<number[][]>;
+	}
+
+	export namespace ai {
+		export function getRelatedInformation(query: string, types: RelatedInformationType[], token: CancellationToken): Thenable<RelatedInformationResult[]>;
+		export function registerRelatedInformationProvider(type: RelatedInformationType, provider: RelatedInformationProvider): Disposable;
+		export function registerEmbeddingVectorProvider(model: string, provider: EmbeddingVectorProvider): Disposable;
+	}
+}

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

@@ -0,0 +1,62 @@
+/*---------------------------------------------------------------------------------------------
+ *  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/152399
+
+	export interface AuthenticationForceNewSessionOptions {
+		/**
+		 * The session that you are asking to be recreated. The Auth Provider can use this to
+		 * help guide the user to log in to the correct account.
+		 */
+		sessionToRecreate?: AuthenticationSession;
+	}
+
+	export namespace authentication {
+		/**
+		 * Get all authentication sessions matching the desired scopes that this extension has access to. In order to request access,
+		 * use {@link getSession}. To request an additional account, specify {@link AuthenticationGetSessionOptions.clearSessionPreference}
+		 * and {@link AuthenticationGetSessionOptions.createIfNone} together.
+		 *
+		 * Currently, there are only two authentication providers that are contributed from built in extensions
+		 * to the editor that implement GitHub and Microsoft authentication: their providerId's are 'github' and 'microsoft'.
+		 *
+		 * @param providerId The id of the provider to use
+		 * @param scopes A list of scopes representing the permissions requested. These are dependent on the authentication provider
+		 * @returns A thenable that resolves to a readonly array of authentication sessions.
+		 */
+		export function getSessions(providerId: string, scopes: readonly string[]): Thenable<readonly AuthenticationSession[]>;
+	}
+
+	/**
+	 * The options passed in to the provider when creating a session.
+	 */
+	export interface AuthenticationProviderCreateSessionOptions {
+		/**
+		 * The session that is being asked to be recreated. If this is passed in, the provider should
+		 * attempt to recreate the session based on the information in this session.
+		 */
+		sessionToRecreate?: AuthenticationSession;
+	}
+
+	export interface AuthenticationProvider {
+		/**
+		 * Prompts a user to login.
+		 *
+		 * If login is successful, the onDidChangeSessions event should be fired.
+		 *
+		 * If login fails, a rejected promise should be returned.
+		 *
+		 * If the provider has specified that it does not support multiple accounts,
+		 * then this should never be called if there is already an existing session matching these
+		 * scopes.
+		 * @param scopes A list of scopes, permissions, that the new session should be created with.
+		 * @param options Additional options for creating a session.
+		 * @returns A promise that resolves to an authentication session.
+		 */
+		createSession(scopes: readonly string[], options: AuthenticationProviderCreateSessionOptions): Thenable<AuthenticationSession>;
+	}
+}

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

@@ -0,0 +1,13 @@
+/*---------------------------------------------------------------------------------------------
+ *  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' {
+	export namespace authentication {
+		/**
+		 * @deprecated Use {@link getSession()} {@link AuthenticationGetSessionOptions.silent} instead.
+		 */
+		export function hasSession(providerId: string, scopes: readonly string[]): Thenable<boolean>;
+	}
+}

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

@@ -0,0 +1,47 @@
+/*---------------------------------------------------------------------------------------------
+ *  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/180582
+
+	export namespace workspace {
+		/**
+		 *
+		 * @param scheme The URI scheme that this provider can provide canonical URIs for.
+		 * A canonical URI represents the conversion of a resource's alias into a source of truth URI.
+		 * Multiple aliases may convert to the same source of truth URI.
+		 * @param provider A provider which can convert URIs of scheme @param scheme to
+		 * a canonical URI which is stable across machines.
+		 */
+		export function registerCanonicalUriProvider(scheme: string, provider: CanonicalUriProvider): Disposable;
+
+		/**
+		 *
+		 * @param uri The URI to provide a canonical URI for.
+		 * @param token A cancellation token for the request.
+		 */
+		export function getCanonicalUri(uri: Uri, options: CanonicalUriRequestOptions, token: CancellationToken): ProviderResult<Uri>;
+	}
+
+	export interface CanonicalUriProvider {
+		/**
+		 *
+		 * @param uri The URI to provide a canonical URI for.
+		 * @param options Options that the provider should honor in the URI it returns.
+		 * @param token A cancellation token for the request.
+		 * @returns The canonical URI for the requested URI or undefined if no canonical URI can be provided.
+		 */
+		provideCanonicalUri(uri: Uri, options: CanonicalUriRequestOptions, token: CancellationToken): ProviderResult<Uri>;
+	}
+
+	export interface CanonicalUriRequestOptions {
+		/**
+		 *
+		 * The desired scheme of the canonical URI.
+		 */
+		targetScheme: string;
+	}
+}

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

@@ -0,0 +1,25 @@
+/*---------------------------------------------------------------------------------------------
+ *  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' {
+
+	// ChatML
+	export enum ChatMessageRole {
+		System = 0,
+		User = 1,
+		Assistant = 2,
+		Function = 3,
+	}
+
+	// ChatML
+	export class ChatMessage {
+		role: ChatMessageRole;
+		content: string;
+		name?: string;
+
+		constructor(role: ChatMessageRole, content: string);
+	}
+
+}

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

@@ -0,0 +1,39 @@
+/*---------------------------------------------------------------------------------------------
+ *  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' {
+
+	export interface ChatAgentContext {
+		history: ChatMessage[];
+	}
+
+	export interface ChatAgentResponse {
+		message: MarkdownString | InteractiveProgressFileTree;
+	}
+
+	export interface ChatAgentResult {
+		followUp?: InteractiveSessionFollowup[];
+	}
+
+	export interface ChatAgentCommand {
+		name: string;
+		description: string;
+	}
+
+	export interface ChatAgentMetadata {
+		description: string;
+		fullName?: string;
+		icon?: Uri;
+		subCommands: ChatAgentCommand[];
+	}
+
+	export interface ChatAgent {
+		(prompt: ChatMessage, context: ChatAgentContext, progress: Progress<ChatAgentResponse>, token: CancellationToken): Thenable<ChatAgentResult | void>;
+	}
+
+	export namespace chat {
+		export function registerAgent(id: string, agent: ChatAgent, metadata: ChatAgentMetadata): Disposable;
+	}
+}

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

@@ -0,0 +1,38 @@
+/*---------------------------------------------------------------------------------------------
+ *  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' {
+
+	export interface ChatResponseFragment {
+		index: number;
+		part: string;
+	}
+
+	/**
+	 * Represents a large language model that accepts ChatML messages and produces a streaming response
+	 */
+	export interface ChatResponseProvider {
+		provideChatResponse(messages: ChatMessage[], options: { [name: string]: any }, progress: Progress<ChatResponseFragment>, token: CancellationToken): Thenable<any>;
+	}
+
+	export interface ChatResponseProviderMetadata {
+		// TODO: add way to compute token count
+		name: string;
+	}
+
+	export namespace chat {
+
+		/**
+		 * Register a LLM as chat response provider to the editor.
+		 *
+		 *
+		 * @param id
+		 * @param provider
+		 * @param metadata
+		 */
+		export function registerChatResponseProvider(id: string, provider: ChatResponseProvider, metadata: ChatResponseProviderMetadata): Disposable;
+	}
+
+}

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

@@ -0,0 +1,47 @@
+/*---------------------------------------------------------------------------------------------
+ *  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' {
+
+	export interface ChatResponseFragment {
+		index: number;
+		part: string;
+	}
+
+	/**
+	 * Represents access to using a chat provider (LLM). Access is granted and temporary, usually only valid
+	 * for the duration of an user interaction.
+	 */
+	export interface ChatAccess {
+
+		/**
+		 * Whether the access to chat has been revoked. This happens when the user interaction that allowed for
+		 * chat access is finished.
+		 */
+		isRevoked: boolean;
+
+		/**
+		 * TODO: return an AsyncIterable instead of asking to pass Progress<...>?
+		 *
+		 * @param messages
+		 * @param options
+		 * @param progress
+		 * @param token
+		 */
+		makeRequest(messages: ChatMessage[], options: { [name: string]: any }, progress: Progress<ChatResponseFragment>, token: CancellationToken): Thenable<any>;
+	}
+
+	export namespace chat {
+
+		/**
+		 * Request access to chat.
+		 *
+		 * *Note* that this function will throw an error unless an user interaction is currently active.
+		 *
+		 * @param id The id of the chat provider, e.g `copilot`
+		 */
+		export function requestChatAccess(id: string): Thenable<ChatAccess>;
+	}
+}